├── .gitignore ├── README.md ├── db_api.py ├── function_calling_demo.ipynb ├── requirements.txt └── streamlit ├── app.py └── utils ├── callback.py └── funcs ├── db_interactions.py └── rag_pipeline.py /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | share/python-wheels/ 24 | *.egg-info/ 25 | .installed.cfg 26 | *.egg 27 | MANIFEST 28 | 29 | # PyInstaller 30 | # Usually these files are written by a python script from a template 31 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 32 | *.manifest 33 | *.spec 34 | 35 | # Installer logs 36 | pip-log.txt 37 | pip-delete-this-directory.txt 38 | 39 | # Unit test / coverage reports 40 | htmlcov/ 41 | .tox/ 42 | .nox/ 43 | .coverage 44 | .coverage.* 45 | .cache 46 | nosetests.xml 47 | coverage.xml 48 | *.cover 49 | *.py,cover 50 | .hypothesis/ 51 | .pytest_cache/ 52 | cover/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | .pybuilder/ 76 | target/ 77 | 78 | # Jupyter Notebook 79 | .ipynb_checkpoints 80 | 81 | # IPython 82 | profile_default/ 83 | ipython_config.py 84 | 85 | # pyenv 86 | # For a library or package, you might want to ignore these files since the code is 87 | # intended to run in multiple environments; otherwise, check them in: 88 | # .python-version 89 | 90 | # pipenv 91 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 92 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 93 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 94 | # install all needed dependencies. 95 | #Pipfile.lock 96 | 97 | # poetry 98 | # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. 99 | # This is especially recommended for binary packages to ensure reproducibility, and is more 100 | # commonly ignored for libraries. 101 | # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control 102 | #poetry.lock 103 | 104 | # pdm 105 | # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. 106 | #pdm.lock 107 | # pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it 108 | # in version control. 109 | # https://pdm.fming.dev/#use-with-ide 110 | .pdm.toml 111 | 112 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm 113 | __pypackages__/ 114 | 115 | # Celery stuff 116 | celerybeat-schedule 117 | celerybeat.pid 118 | 119 | # SageMath parsed files 120 | *.sage.py 121 | 122 | # Environments 123 | .env 124 | .venv 125 | env/ 126 | venv/ 127 | ENV/ 128 | env.bak/ 129 | venv.bak/ 130 | 131 | # Service account 132 | service-accounts 133 | 134 | # Spyder project settings 135 | .spyderproject 136 | .spyproject 137 | 138 | # Rope project settings 139 | .ropeproject 140 | 141 | # mkdocs documentation 142 | /site 143 | 144 | # mypy 145 | .mypy_cache/ 146 | .dmypy.json 147 | dmypy.json 148 | 149 | # Pyre type checker 150 | .pyre/ 151 | 152 | # pytype static type analyzer 153 | .pytype/ 154 | 155 | # Cython debug symbols 156 | cython_debug/ 157 | 158 | # PyCharm 159 | # JetBrains specific template is maintained in a separate JetBrains.gitignore that can 160 | # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore 161 | # and can be added to the global gitignore or merged into this file. For a more nuclear 162 | # option (not recommended) you can uncomment the following to ignore the entire idea folder. 163 | #.idea/ -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Function Calling demo 2 | ## What does this application wants to demonstrate 3 | This application is built as an extension to [this](https://haystack.deepset.ai/tutorials/40_building_chat_application_with_function_calling) 4 | 1. **Data retrieval**: With both RAG and DB search (via API created from Flask) 5 | 2. **Routing**: Use Function Call for autonomous tool choice & invocation 6 | 3. **UI** Via Streamlit 7 | 8 | ## Tech stack 9 | - **Embedding model**: [all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) 10 | - **Vector Database**: [Haystack's InMemoryDocumentStore](https://docs.haystack.deepset.ai/docs/inmemorydocumentstore) 11 | - **LLM**: [GPT-4 Turbo accessed via OpenRouter](https://openrouter.ai/models/openai/gpt-4-1106-preview). But the flow can be adapted into using other LLMs 12 | - **LLM Framework**: [Haystack](https://haystack.deepset.ai/) for their great documentations, and transparency in pipeline construction. This tutorial is actually an extension to their [fantastic tutorial](https://haystack.deepset.ai/tutorials/40_building_chat_application_with_function_calling) for the same topic 13 | 14 | ## Running this tool 15 | 1. Create and activate a virtual environment, then `pip install -r requirements.txt` to install the required packages 16 | 1. Spin up the API server with `python db_api.py` 17 | 2. If you are seeking for an initial tutorial for the concept behind, run `rag_plus_db_search.ipynb`. Or proceed to #3 directly 18 | 3. Run the streamlit application with the below 19 | ``` 20 | export OPENROUTER_API_KEY = '@REPLACE WITH YOUR API KEY' 21 | cd streamlit 22 | streamlit run app.py 23 | ``` -------------------------------------------------------------------------------- /db_api.py: -------------------------------------------------------------------------------- 1 | # Create a flask application to interact with the database with CRUD operations 2 | # This file contains the API for the database operations 3 | 4 | from flask import Flask, request, jsonify 5 | from flask_sqlalchemy import SQLAlchemy 6 | from flask_marshmallow import Marshmallow 7 | import os 8 | 9 | # Initialize the flask application 10 | app = Flask(__name__) 11 | basedir = os.path.abspath(os.path.dirname(__file__)) 12 | # Database configuration 13 | app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:' 14 | app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False 15 | # Initialize the database 16 | db = SQLAlchemy(app) 17 | # Initialize the marshmallow 18 | ma = Marshmallow(app) 19 | 20 | # Create a class for the database model 21 | 22 | class Item(db.Model): 23 | id = db.Column(db.Integer, primary_key=True) 24 | name_en = db.Column(db.String(255), nullable=False) 25 | name_cn = db.Column(db.String(255), nullable=False) 26 | category = db.Column(db.String(255), nullable=False) 27 | price = db.Column(db.Float, nullable=False) 28 | quantity = db.Column(db.Integer, nullable=False) 29 | 30 | def __init__(self, name_en, name_cn, category, price, quantity): 31 | self.name_en = name_en 32 | self.name_cn = name_cn 33 | self.category = category 34 | self.price = price 35 | self.quantity = quantity 36 | 37 | # Create a schema for the database model 38 | class ItemSchema(ma.Schema): 39 | class Meta: 40 | fields = ('id', 'name_en', 'name_cn', 'category', 'price', 'quantity') 41 | 42 | # Initialize the schema 43 | item_schema = ItemSchema() 44 | items_schema = ItemSchema(many=True) 45 | 46 | # Add sample data to the database 47 | app.app_context().push() 48 | db.create_all() 49 | initial_items = [ 50 | Item('Water', '水', 'Food and beverages', 1.0, 100), 51 | Item('Coca-cola', '可樂', 'Food and beverages', 2.0, 200), 52 | Item('Hamburger', '漢堡包', 'Food and beverages', 13.0, 0), 53 | Item('Fried rice', '炒飯', 'Food and beverages', 9.0, 300), 54 | Item('Newspaper', '報紙', 'Miscellaneous', 2.0, 100), 55 | Item('Cigarettes', '煙', 'Miscellaneous', 5.0, 100), 56 | ] 57 | for item in initial_items: 58 | db.session.add(item) 59 | db.session.commit() 60 | 61 | # Create a route to add a item to the database 62 | # @app.route('/item', methods=['POST']) 63 | # def add_item(): 64 | # name_en = request.json['name_en'] 65 | # name_cn = request.json['name_cn'] 66 | # price = request.json['price'] 67 | # quantity = request.json['quantity'] 68 | 69 | # new_item = Item(name_en, name_cn, price, quantity) 70 | 71 | # db.session.add(new_item) 72 | # db.session.commit() 73 | 74 | # return item_schema.jsonify(new_item) 75 | 76 | # Create a route to get all the items from the database 77 | # @app.route('/item', methods=['GET']) 78 | # def get_items(): 79 | # all_items = Item.query.all() 80 | # result = items_schema.dump(all_items) 81 | # return jsonify(result) 82 | 83 | # Create a route to get the unique categories 84 | @app.route('/category', methods=['GET']) 85 | def get_categories(): 86 | categories = Item.query.with_entities(Item.category).distinct().all() 87 | result = [category[0] for category in categories] 88 | return jsonify(result) 89 | 90 | # Create a route to get a item by ids, multiple ids are separated by comma 91 | @app.route('/item', methods=['GET']) 92 | def get_items(): 93 | ids = request.args.get('id') 94 | categories = request.args.get('category') 95 | if ids: 96 | ids = ids.split(',') 97 | items = Item.query.filter(Item.id.in_(ids)).all() 98 | result = items_schema.dump(items) 99 | elif categories: 100 | categories = categories.split(',') 101 | items = Item.query.filter(Item.category.in_(categories)).all() 102 | result = items_schema.dump(items) 103 | else: 104 | items = Item.query.all() 105 | result = items_schema.dump(items) 106 | return jsonify(result) 107 | 108 | # # Create a route to update a item by id 109 | # @app.route('/item/', methods=['PUT']) 110 | # def update_item(id): 111 | # item = Item.query.get(id) 112 | # name_en = request.json['name_en'] 113 | # name_cn = request.json['name_cn'] 114 | # price = request.json['price'] 115 | # quantity = request.json['quantity'] 116 | 117 | # item.name_en = name_en 118 | # item.name_cn = name_cn 119 | # item.price = price 120 | # item.quantity = quantity 121 | 122 | # db.session.commit() 123 | 124 | # return item_schema.jsonify(item) 125 | 126 | # # Create a route to delete a item by id 127 | # @app.route('/item/', methods=['DELETE']) 128 | # def delete_item(id): 129 | # item = Item.query.get(id) 130 | # db.session.delete(item) 131 | # db.session.commit() 132 | 133 | # return item_schema.jsonify(item) 134 | 135 | # Create a route to deduct the quantity of a item by id 136 | @app.route('/item/purchase', methods=['POST']) 137 | def purchase_item(): 138 | 139 | id = request.json['id'] 140 | quantity = request.json['quantity'] 141 | item = Item.query.get(id) 142 | 143 | item.quantity = item.quantity - quantity 144 | 145 | db.session.commit() 146 | 147 | return item_schema.jsonify(item) 148 | 149 | # Run the application 150 | if __name__ == '__main__': 151 | app.run(debug=True) 152 | 153 | # End of file -------------------------------------------------------------------------------- /function_calling_demo.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Initialization" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "In this demo we are calling LLMs from OpenRouter, because with it you can access different LLM APIs from Hong Kong. But using the original OpenAIChatGenerator without overwritting the `api_base_url` would also work" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": null, 20 | "metadata": {}, 21 | "outputs": [], 22 | "source": [ 23 | "import os\n", 24 | "from dotenv import load_dotenv\n", 25 | "from haystack.components.generators.chat import OpenAIChatGenerator\n", 26 | "from haystack.utils import Secret\n", 27 | "from haystack.dataclasses import ChatMessage\n", 28 | "from haystack.components.generators.utils import print_streaming_chunk\n", 29 | "\n", 30 | "# Set your API key as environment variable before executing this\n", 31 | "load_dotenv()\n", 32 | "OPENROUTER_API_KEY = os.environ.get('OPENROUTER_API_KEY')\n", 33 | "\n", 34 | "chat_generator = OpenAIChatGenerator(api_key=Secret.from_env_var(\"OPENROUTER_API_KEY\"),\n", 35 | "\t\tapi_base_url=\"https://openrouter.ai/api/v1\",\n", 36 | "\t\tmodel=\"openai/gpt-4-turbo-preview\",\n", 37 | " streaming_callback=print_streaming_chunk)\n", 38 | "\n", 39 | "chat_generator.run(messages=[ChatMessage.from_user(\"Return this text: 'test'\")])" 40 | ] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "# Step 1 - Establish data store" 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "## Index Documents with a Pipeline\n", 54 | "Here we provide sample texts for the model to perform Retrival Augmented Generation (RAG). The texts are turned into embeddings and stored in an in-memory document store" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": 2, 60 | "metadata": {}, 61 | "outputs": [ 62 | { 63 | "name": "stderr", 64 | "output_type": "stream", 65 | "text": [ 66 | "Batches: 100%|██████████| 1/1 [00:00<00:00, 1.17it/s]\n" 67 | ] 68 | }, 69 | { 70 | "data": { 71 | "text/plain": [ 72 | "{'doc_writer': {'documents_written': 2}}" 73 | ] 74 | }, 75 | "execution_count": 2, 76 | "metadata": {}, 77 | "output_type": "execute_result" 78 | } 79 | ], 80 | "source": [ 81 | "from haystack import Pipeline, Document\n", 82 | "from haystack.document_stores.in_memory import InMemoryDocumentStore\n", 83 | "from haystack.components.writers import DocumentWriter\n", 84 | "from haystack.components.embedders import SentenceTransformersDocumentEmbedder\n", 85 | "\n", 86 | "# Sample documents\n", 87 | "documents = [\n", 88 | " Document(content=\"Coffee shop opens at 9am and closes at 5pm.\"),\n", 89 | " Document(content=\"Gym room opens at 6am and closes at 10pm.\")\n", 90 | "]\n", 91 | "\n", 92 | "# Create the document store\n", 93 | "document_store = InMemoryDocumentStore()\n", 94 | "\n", 95 | "# Create a pipeline to turn the texts into embeddings and store them in the document store\n", 96 | "indexing_pipeline = Pipeline()\n", 97 | "indexing_pipeline.add_component(\n", 98 | " \"doc_embedder\", SentenceTransformersDocumentEmbedder(model=\"sentence-transformers/all-MiniLM-L6-v2\")\n", 99 | ")\n", 100 | "indexing_pipeline.add_component(\"doc_writer\", DocumentWriter(document_store=document_store))\n", 101 | "\n", 102 | "indexing_pipeline.connect(\"doc_embedder.documents\", \"doc_writer.documents\")\n", 103 | "\n", 104 | "indexing_pipeline.run({\"doc_embedder\": {\"documents\": documents}})" 105 | ] 106 | }, 107 | { 108 | "cell_type": "markdown", 109 | "metadata": {}, 110 | "source": [ 111 | "## Spin up API server" 112 | ] 113 | }, 114 | { 115 | "cell_type": "markdown", 116 | "metadata": {}, 117 | "source": [ 118 | "An API server made with Flask is created under `db_api.py` to connect to SQLite. Please spin it up by running `python db_api.py` in your terminal " 119 | ] 120 | }, 121 | { 122 | "cell_type": "markdown", 123 | "metadata": {}, 124 | "source": [ 125 | "# Step 2 - Define the functions\n", 126 | "Here we prepare the actual functions for the model to invoke AFTER Function Calling. Function Calling provides ONLY the arguments for you to invoke these functions, it does not invoke the functions themselves" 127 | ] 128 | }, 129 | { 130 | "cell_type": "markdown", 131 | "metadata": {}, 132 | "source": [ 133 | "## RAG function\n", 134 | "Namely the `rag_pipeline_func`. This is for the model to provide an answer by searching through the texts stored in the Document Store. We first define the RAG retrieval as a Haystack pipeline" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 3, 140 | "metadata": {}, 141 | "outputs": [ 142 | { 143 | "data": { 144 | "image/png": "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", 145 | "text/plain": [ 146 | "" 147 | ] 148 | }, 149 | "metadata": {}, 150 | "output_type": "display_data" 151 | }, 152 | { 153 | "data": { 154 | "text/plain": [] 155 | }, 156 | "execution_count": 3, 157 | "metadata": {}, 158 | "output_type": "execute_result" 159 | } 160 | ], 161 | "source": [ 162 | "from haystack.components.embedders import SentenceTransformersTextEmbedder\n", 163 | "from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever\n", 164 | "from haystack.components.builders import PromptBuilder\n", 165 | "from haystack.components.generators import OpenAIGenerator\n", 166 | "\n", 167 | "template = \"\"\"\n", 168 | "Answer the questions based on the given context.\n", 169 | "\n", 170 | "Context:\n", 171 | "{% for document in documents %}\n", 172 | " {{ document.content }}\n", 173 | "{% endfor %}\n", 174 | "Question: {{ question }}\n", 175 | "Answer:\n", 176 | "\"\"\"\n", 177 | "rag_pipe = Pipeline()\n", 178 | "rag_pipe.add_component(\"embedder\", SentenceTransformersTextEmbedder(model=\"sentence-transformers/all-MiniLM-L6-v2\"))\n", 179 | "rag_pipe.add_component(\"retriever\", InMemoryEmbeddingRetriever(document_store=document_store))\n", 180 | "rag_pipe.add_component(\"prompt_builder\", PromptBuilder(template=template))\n", 181 | "# Note to llm: We are using OpenAIGenerator, not the OpenAIChatGenerator, because the latter only accepts List[str] as input and cannot accept prompt_builder's str output\n", 182 | "rag_pipe.add_component(\"llm\", OpenAIGenerator(api_key=Secret.from_env_var(\"OPENROUTER_API_KEY\"),\n", 183 | "\t\tapi_base_url=\"https://openrouter.ai/api/v1\",\n", 184 | "\t\tmodel=\"openai/gpt-4-turbo-preview\"))\n", 185 | "\n", 186 | "rag_pipe.connect(\"embedder.embedding\", \"retriever.query_embedding\")\n", 187 | "rag_pipe.connect(\"retriever\", \"prompt_builder.documents\")\n", 188 | "rag_pipe.connect(\"prompt_builder\", \"llm\")" 189 | ] 190 | }, 191 | { 192 | "cell_type": "markdown", 193 | "metadata": {}, 194 | "source": [ 195 | "Test if the pipeline works" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": 4, 201 | "metadata": {}, 202 | "outputs": [ 203 | { 204 | "name": "stderr", 205 | "output_type": "stream", 206 | "text": [ 207 | "Batches: 100%|██████████| 1/1 [00:00<00:00, 63.95it/s]\n" 208 | ] 209 | }, 210 | { 211 | "data": { 212 | "text/plain": [ 213 | "{'llm': {'replies': ['The coffee shop opens at 9am.'],\n", 214 | " 'meta': [{'model': 'openai/gpt-4-turbo-preview',\n", 215 | " 'index': 0,\n", 216 | " 'finish_reason': 'stop',\n", 217 | " 'usage': {'completion_tokens': 9,\n", 218 | " 'prompt_tokens': 60,\n", 219 | " 'total_tokens': 69,\n", 220 | " 'total_cost': 0.00087}}]}}" 221 | ] 222 | }, 223 | "execution_count": 4, 224 | "metadata": {}, 225 | "output_type": "execute_result" 226 | } 227 | ], 228 | "source": [ 229 | "query = \"When does the coffee shop open?\"\n", 230 | "rag_pipe.run({\"embedder\": {\"text\": query}, \"prompt_builder\": {\"question\": query}})" 231 | ] 232 | }, 233 | { 234 | "cell_type": "markdown", 235 | "metadata": {}, 236 | "source": [ 237 | "The pipeline is turned into a function" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": 5, 243 | "metadata": {}, 244 | "outputs": [], 245 | "source": [ 246 | "def rag_pipeline_func(query: str):\n", 247 | " result = rag_pipe.run({\"embedder\": {\"text\": query}, \"prompt_builder\": {\"question\": query}})\n", 248 | "\n", 249 | " return {\"reply\": result[\"llm\"][\"replies\"][0]}" 250 | ] 251 | }, 252 | { 253 | "cell_type": "markdown", 254 | "metadata": {}, 255 | "source": [ 256 | "## API calls\n", 257 | "For interacting with the API server, which in turns interact with our database" 258 | ] 259 | }, 260 | { 261 | "cell_type": "code", 262 | "execution_count": 6, 263 | "metadata": {}, 264 | "outputs": [], 265 | "source": [ 266 | "# Flask's default local URL, change it if necessary\n", 267 | "db_base_url = 'http://127.0.0.1:5000'\n", 268 | "\n", 269 | "# Use requests to get the data from the database\n", 270 | "import requests\n", 271 | "import json\n", 272 | "\n", 273 | "def get_categories():\n", 274 | " response = requests.get(f'{db_base_url}/category')\n", 275 | " data = response.json()\n", 276 | " return data\n", 277 | "\n", 278 | "def get_items(ids=None,categories=None):\n", 279 | " params = {\n", 280 | " 'id': ids,\n", 281 | " 'category': categories,\n", 282 | " }\n", 283 | " response = requests.get(f'{db_base_url}/item', params=params)\n", 284 | " data = response.json()\n", 285 | " return data\n", 286 | "\n", 287 | "def purchase_item(id,quantity):\n", 288 | "\n", 289 | " headers = {\n", 290 | " 'Content-type':'application/json', \n", 291 | " 'Accept':'application/json'\n", 292 | " }\n", 293 | "\n", 294 | " data = {\n", 295 | " 'id': id,\n", 296 | " 'quantity': quantity,\n", 297 | " }\n", 298 | " response = requests.post(f'{db_base_url}/item/purchase', json=data, headers=headers)\n", 299 | " return response.json()" 300 | ] 301 | }, 302 | { 303 | "cell_type": "markdown", 304 | "metadata": {}, 305 | "source": [ 306 | "## Define the tool list\n", 307 | "Now that we have defined the fuctions, we need to let the model to recognize those functions, and to instruct them how they are used, by providing descriptions for them." 308 | ] 309 | }, 310 | { 311 | "cell_type": "code", 312 | "execution_count": 7, 313 | "metadata": {}, 314 | "outputs": [], 315 | "source": [ 316 | "tools = [\n", 317 | " {\n", 318 | " \"type\": \"function\",\n", 319 | " \"function\": {\n", 320 | " \"name\": \"get_items\",\n", 321 | " \"description\": \"Get a list of items from the database\",\n", 322 | " \"parameters\": {\n", 323 | " \"type\": \"object\",\n", 324 | " \"properties\": {\n", 325 | " \"ids\": {\n", 326 | " \"type\": \"string\",\n", 327 | " \"description\": \"Comma separated list of item ids to fetch\",\n", 328 | " },\n", 329 | " \"categories\": {\n", 330 | " \"type\": \"string\",\n", 331 | " \"description\": \"Comma separated list of item categories to fetch\",\n", 332 | " },\n", 333 | " },\n", 334 | " \"required\": [],\n", 335 | " },\n", 336 | " }\n", 337 | " },\n", 338 | " {\n", 339 | " \"type\": \"function\",\n", 340 | " \"function\": {\n", 341 | " \"name\": \"purchase_item\",\n", 342 | " \"description\": \"Purchase a particular item\",\n", 343 | " \"parameters\": {\n", 344 | " \"type\": \"object\",\n", 345 | " \"properties\": {\n", 346 | " \"id\": {\n", 347 | " \"type\": \"string\",\n", 348 | " \"description\": \"The given product ID, product name is not accepted here. Please obtain the product ID from the database first.\",\n", 349 | " },\n", 350 | " \"quantity\": {\n", 351 | " \"type\": \"integer\",\n", 352 | " \"description\": \"Number of items to purchase\",\n", 353 | " },\n", 354 | " },\n", 355 | " \"required\": [],\n", 356 | " },\n", 357 | " }\n", 358 | " },\n", 359 | " {\n", 360 | " \"type\": \"function\",\n", 361 | " \"function\": {\n", 362 | " \"name\": \"rag_pipeline_func\",\n", 363 | " \"description\": \"Get information from hotel brochure\",\n", 364 | " \"parameters\": {\n", 365 | " \"type\": \"object\",\n", 366 | " \"properties\": {\n", 367 | " \"query\": {\n", 368 | " \"type\": \"string\",\n", 369 | " \"description\": \"The query to use in the search. Infer this from the user's message. It should be a question or a statement\",\n", 370 | " }\n", 371 | " },\n", 372 | " \"required\": [\"query\"],\n", 373 | " },\n", 374 | " },\n", 375 | " }\n", 376 | "]" 377 | ] 378 | }, 379 | { 380 | "cell_type": "markdown", 381 | "metadata": {}, 382 | "source": [ 383 | "# Step 3: Putting it all together\n", 384 | "We now have the necessary inputs to test Function Calling! Here we do a few things:\n", 385 | "1. Provide the initial prompt to the model, to give it some context\n", 386 | "2. Provide a sample user-generated message\n", 387 | "3. Most importantly, we pass the tool list defined above to the chat generator in `tools`" 388 | ] 389 | }, 390 | { 391 | "cell_type": "code", 392 | "execution_count": 15, 393 | "metadata": {}, 394 | "outputs": [ 395 | { 396 | "data": { 397 | "text/plain": [ 398 | "{'replies': [ChatMessage(content='[{\"index\": 0, \"id\": \"call_AkTWoiJzx5uJSgKW0WAI1yBB\", \"function\": {\"arguments\": \"{\\\\\"categories\\\\\":\\\\\"Food and beverages\\\\\"}\", \"name\": \"get_items\"}, \"type\": \"function\"}]', role=, name=None, meta={'model': 'openai/gpt-4-turbo-preview', 'index': 0, 'finish_reason': 'tool_calls', 'usage': {}})]}" 399 | ] 400 | }, 401 | "execution_count": 15, 402 | "metadata": {}, 403 | "output_type": "execute_result" 404 | } 405 | ], 406 | "source": [ 407 | "# 1. Initial prompt\n", 408 | "context = f\"\"\"You are an assistant to tourists visiting a hotel.\n", 409 | "You have access to a database of items (which includes {get_categories()}) that tourists can buy, you also have access to the hotel's brochure.\n", 410 | "If the tourist's question cannot be answered from the database, you can refer to the brochure.\n", 411 | "If the tourist's question cannot be answered from the brochure, you can ask the tourist to ask the hotel staff.\n", 412 | "\"\"\"\n", 413 | "messages = [\n", 414 | " ChatMessage.from_system(context),\n", 415 | " # 2. Sample message from user\n", 416 | " ChatMessage.from_user(\"Can I buy a coffee?\"),\n", 417 | " ]\n", 418 | "\n", 419 | "# 3. Passing the tools list and invoke the chat generator\n", 420 | "response = chat_generator.run(messages=messages, generation_kwargs= {\"tools\": tools})\n", 421 | "response" 422 | ] 423 | }, 424 | { 425 | "cell_type": "markdown", 426 | "metadata": {}, 427 | "source": [ 428 | "Now let's inspect the response. Notice how the Function Calling returns both the function chosen by the model, and the arguments for invoking the chosen function." 429 | ] 430 | }, 431 | { 432 | "cell_type": "code", 433 | "execution_count": 9, 434 | "metadata": {}, 435 | "outputs": [ 436 | { 437 | "name": "stdout", 438 | "output_type": "stream", 439 | "text": [ 440 | "Function Name: get_items\n", 441 | "Function Arguments: {'categories': 'Food and beverages'}\n" 442 | ] 443 | } 444 | ], 445 | "source": [ 446 | "function_call = json.loads(response[\"replies\"][0].content)[0]\n", 447 | "function_name = function_call[\"function\"][\"name\"]\n", 448 | "function_args = json.loads(function_call[\"function\"][\"arguments\"])\n", 449 | "print(\"Function Name:\", function_name)\n", 450 | "print(\"Function Arguments:\", function_args)" 451 | ] 452 | }, 453 | { 454 | "cell_type": "markdown", 455 | "metadata": {}, 456 | "source": [ 457 | "When presented with another question, the model will use another tool that is more relevant" 458 | ] 459 | }, 460 | { 461 | "cell_type": "code", 462 | "execution_count": 10, 463 | "metadata": {}, 464 | "outputs": [ 465 | { 466 | "name": "stdout", 467 | "output_type": "stream", 468 | "text": [ 469 | "Function Name: rag_pipeline_func\n", 470 | "Function Arguments: {'query': \"Where's the coffee shop?\"}\n" 471 | ] 472 | } 473 | ], 474 | "source": [ 475 | "# Another question\n", 476 | "messages.append(ChatMessage.from_user(\"Where's the coffee shop?\"))\n", 477 | "\n", 478 | "# Invoke the chat generator, and passing the tools list\n", 479 | "response = chat_generator.run(messages=messages, generation_kwargs= {\"tools\": tools})\n", 480 | "function_call = json.loads(response[\"replies\"][0].content)[0]\n", 481 | "function_name = function_call[\"function\"][\"name\"]\n", 482 | "function_args = json.loads(function_call[\"function\"][\"arguments\"])\n", 483 | "print(\"Function Name:\", function_name)\n", 484 | "print(\"Function Arguments:\", function_args)" 485 | ] 486 | }, 487 | { 488 | "cell_type": "markdown", 489 | "metadata": {}, 490 | "source": [ 491 | "Notice that no actual function is invoked here, this is what we will do next" 492 | ] 493 | }, 494 | { 495 | "cell_type": "markdown", 496 | "metadata": {}, 497 | "source": [ 498 | "## Calling the function\n", 499 | "We can then feed the arguments into the chosen function" 500 | ] 501 | }, 502 | { 503 | "cell_type": "code", 504 | "execution_count": 11, 505 | "metadata": {}, 506 | "outputs": [ 507 | { 508 | "name": "stderr", 509 | "output_type": "stream", 510 | "text": [ 511 | "Batches: 100%|██████████| 1/1 [00:00<00:00, 63.99it/s]\n" 512 | ] 513 | }, 514 | { 515 | "name": "stdout", 516 | "output_type": "stream", 517 | "text": [ 518 | "Function Response: {'reply': 'The provided context does not specify a physical location for the coffee shop, only its operating hours. Therefore, I cannot determine where the coffee shop is located based on the given information.'}\n" 519 | ] 520 | } 521 | ], 522 | "source": [ 523 | "## Find the correspoding function and call it with the given arguments\n", 524 | "available_functions = {\"get_items\": get_items, \"purchase_item\": purchase_item,\"rag_pipeline_func\": rag_pipeline_func}\n", 525 | "function_to_call = available_functions[function_name]\n", 526 | "function_response = function_to_call(**function_args)\n", 527 | "print(\"Function Response:\", function_response)" 528 | ] 529 | }, 530 | { 531 | "cell_type": "markdown", 532 | "metadata": {}, 533 | "source": [ 534 | "The response can then passed as a context to the chat, under the `messages` argument." 535 | ] 536 | }, 537 | { 538 | "cell_type": "code", 539 | "execution_count": 12, 540 | "metadata": {}, 541 | "outputs": [ 542 | { 543 | "name": "stdout", 544 | "output_type": "stream", 545 | "text": [ 546 | "For the location of the coffee shop within the hotel, I recommend asking the hotel staff directly. They will be able to guide you to it accurately.For the location of the coffee shop within the hotel, I recommend asking the hotel staff directly. They will be able to guide you to it accurately.\n" 547 | ] 548 | } 549 | ], 550 | "source": [ 551 | "messages.append(ChatMessage.from_function(content=json.dumps(function_response), name=function_name))\n", 552 | "response = chat_generator.run(messages=messages)\n", 553 | "response_msg = response[\"replies\"][0]\n", 554 | "\n", 555 | "print(response_msg.content)" 556 | ] 557 | }, 558 | { 559 | "cell_type": "markdown", 560 | "metadata": {}, 561 | "source": [ 562 | "We now have completed the chat cycle!" 563 | ] 564 | }, 565 | { 566 | "cell_type": "markdown", 567 | "metadata": {}, 568 | "source": [ 569 | "## Turn into interactive chat\n", 570 | "The below code is copied from [Haystack's tutorial](https://haystack.deepset.ai/tutorials/40_building_chat_application_with_function_calling). However, for interactive chat we better hook the model to Streamlit to provide a neat ChatGPT-like UI" 571 | ] 572 | }, 573 | { 574 | "cell_type": "code", 575 | "execution_count": null, 576 | "metadata": {}, 577 | "outputs": [], 578 | "source": [ 579 | "import json\n", 580 | "from haystack.dataclasses import ChatMessage, ChatRole\n", 581 | "\n", 582 | "response = None\n", 583 | "messages = [\n", 584 | " ChatMessage.from_system(context)\n", 585 | "]\n", 586 | "\n", 587 | "while True:\n", 588 | " # if OpenAI response is a tool call\n", 589 | " if response and response[\"replies\"][0].meta[\"finish_reason\"] == \"tool_calls\":\n", 590 | " function_calls = json.loads(response[\"replies\"][0].content)\n", 591 | "\n", 592 | " for function_call in function_calls:\n", 593 | " ## Parse function calling information\n", 594 | " function_name = function_call[\"function\"][\"name\"]\n", 595 | " function_args = json.loads(function_call[\"function\"][\"arguments\"])\n", 596 | "\n", 597 | " ## Find the correspoding function and call it with the given arguments\n", 598 | " function_to_call = available_functions[function_name]\n", 599 | " function_response = function_to_call(**function_args)\n", 600 | "\n", 601 | " ## Append function response to the messages list using `ChatMessage.from_function`\n", 602 | " messages.append(ChatMessage.from_function(content=json.dumps(function_response), name=function_name))\n", 603 | "\n", 604 | " # Regular Conversation\n", 605 | " else:\n", 606 | " # Append assistant messages to the messages list\n", 607 | " if not messages[-1].is_from(ChatRole.SYSTEM):\n", 608 | " messages.append(response[\"replies\"][0])\n", 609 | "\n", 610 | " user_input = input(\"ENTER YOUR MESSAGE 👇 INFO: Type 'exit' or 'quit' to stop\\n\")\n", 611 | " if user_input.lower() == \"exit\" or user_input.lower() == \"quit\":\n", 612 | " break\n", 613 | " else:\n", 614 | " messages.append(ChatMessage.from_user(user_input))\n", 615 | "\n", 616 | " response = chat_generator.run(messages=messages, generation_kwargs={\"tools\": tools})" 617 | ] 618 | } 619 | ], 620 | "metadata": { 621 | "kernelspec": { 622 | "display_name": "venv", 623 | "language": "python", 624 | "name": "python3" 625 | }, 626 | "language_info": { 627 | "codemirror_mode": { 628 | "name": "ipython", 629 | "version": 3 630 | }, 631 | "file_extension": ".py", 632 | "mimetype": "text/x-python", 633 | "name": "python", 634 | "nbconvert_exporter": "python", 635 | "pygments_lexer": "ipython3", 636 | "version": "3.10.4" 637 | } 638 | }, 639 | "nbformat": 4, 640 | "nbformat_minor": 2 641 | } 642 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | python-dotenv==1.0.1 2 | Flask==3.0.2 3 | Flask_sqlalchemy==3.1.1 4 | flask_marshmallow==1.2.1 5 | marshmallow-sqlalchemy==1.0.0 6 | openai==1.14.3 7 | haystack-ai==2.0.0 8 | sentence-transformers==2.6.1 9 | streamlit==1.32.2 10 | ipykernel==6.25.2 -------------------------------------------------------------------------------- /streamlit/app.py: -------------------------------------------------------------------------------- 1 | import os 2 | from haystack.components.generators.chat import OpenAIChatGenerator 3 | from haystack.utils import Secret 4 | from haystack.dataclasses import ChatMessage 5 | from utils.funcs.db_interactions import get_categories, get_items, purchase_item 6 | from utils.funcs.rag_pipeline import rag_pipeline_func 7 | from utils.callback import StreamlitCallbackHandler 8 | import json 9 | from haystack.dataclasses import ChatMessage, ChatRole 10 | from haystack.components.generators.chat import OpenAIChatGenerator 11 | import streamlit as st 12 | 13 | # Load the API key from the .env file, alternatively declare it in the terminal 14 | OPENROUTER_API_KEY = os.environ.get('OPENROUTER_API_KEY') 15 | 16 | # Prepare the OpenAIChatGenerator for Streamlit 17 | tools = [ 18 | { 19 | "type": "function", 20 | "function": { 21 | "name": "get_items", 22 | "description": "Get a list of items from the database", 23 | "parameters": { 24 | "type": "object", 25 | "properties": { 26 | "ids": { 27 | "type": "string", 28 | "description": "Comma separated list of item ids to fetch", 29 | }, 30 | "categories": { 31 | "type": "string", 32 | "description": "Comma separated list of item categories to fetch", 33 | }, 34 | }, 35 | "required": [], 36 | }, 37 | } 38 | }, 39 | { 40 | "type": "function", 41 | "function": { 42 | "name": "purchase_item", 43 | "description": "Purchase a particular item", 44 | "parameters": { 45 | "type": "object", 46 | "properties": { 47 | "id": { 48 | "type": "string", 49 | "description": "The given product ID, product name is not accepted here. Please obtain the product ID from the database first.", 50 | }, 51 | "quantity": { 52 | "type": "integer", 53 | "description": "Number of items to purchase", 54 | }, 55 | }, 56 | "required": [], 57 | }, 58 | } 59 | }, 60 | { 61 | "type": "function", 62 | "function": { 63 | "name": "rag_pipeline_func", 64 | "description": "Get information from hotel brochure", 65 | "parameters": { 66 | "type": "object", 67 | "properties": { 68 | "query": { 69 | "type": "string", 70 | "description": "The query to use in the search. Infer this from the user's message. It should be a question or a statement", 71 | } 72 | }, 73 | "required": ["query"], 74 | }, 75 | }, 76 | } 77 | ] 78 | 79 | context = f"""You are an assistant to tourists visiting a hotel. 80 | You have access to a database of items (which includes {get_categories()}) that tourists can buy, you also have access to the hotel's brochure. 81 | If the tourist's question cannot be answered by the database, you can refer to the brochure. 82 | If the tourist's question cannot be answered by the brochure, you can ask the tourist to ask the hotel staff. 83 | """ 84 | 85 | available_functions = {"get_items": get_items, "purchase_item": purchase_item,"rag_pipeline_func": rag_pipeline_func} 86 | 87 | # Streamlit chat interface 88 | if "messages" not in st.session_state: 89 | st.session_state["messages"] = [ChatMessage.from_system(context)] 90 | 91 | # Only show chat messages from the user and the assistant. Initial system prompt and function calls are hidden. 92 | for message in st.session_state.messages: 93 | if message.is_from(ChatRole.USER) | message.is_from(ChatRole.ASSISTANT): 94 | with st.chat_message(message.role.name): 95 | st.markdown(message.content) 96 | 97 | if prompt := st.chat_input("ENTER YOUR MESSAGE 👇"): 98 | st.session_state.messages.append(ChatMessage.from_user(prompt)) 99 | with st.chat_message("USER"): 100 | st.markdown(prompt) 101 | 102 | with st.chat_message("ASSISTANT"): 103 | # Initialize the callback handler, which creates an empty container for the responses to be streamed into 104 | st_callback = StreamlitCallbackHandler(st.empty()) 105 | # Initialize the chat generator 106 | chat_generator = OpenAIChatGenerator( 107 | api_key=Secret.from_env_var("OPENROUTER_API_KEY"), 108 | api_base_url="https://openrouter.ai/api/v1", 109 | model="openai/gpt-4-turbo-preview", 110 | streaming_callback=st_callback.on_llm_new_token) 111 | while True: 112 | # Run the chat generator, tool calls will be looped through and executed, until an assistant reply is generated 113 | response = chat_generator.run(messages=st.session_state.messages, generation_kwargs={"tools": tools}) 114 | 115 | if response and response["replies"][0].meta["finish_reason"] == "tool_calls": 116 | function_calls = json.loads(response["replies"][0].content) 117 | 118 | for function_call in function_calls: 119 | ## Parse function calling information 120 | function_name = function_call["function"]["name"] 121 | function_args = json.loads(function_call["function"]["arguments"]) 122 | 123 | ## Find the correspoding function and call it with the given arguments 124 | function_to_call = available_functions[function_name] 125 | function_response = function_to_call(**function_args) 126 | 127 | ## Append function response to the messages list using `ChatMessage.from_function` 128 | st.session_state.messages.append(ChatMessage.from_function(content=json.dumps(function_response), name=function_name)) 129 | # Regular conversation 130 | else: 131 | # Append assistant messages to the messages list 132 | if not st.session_state.messages[-1].is_from(ChatRole.SYSTEM): 133 | st.session_state.messages.append(response["replies"][0]) 134 | break -------------------------------------------------------------------------------- /streamlit/utils/callback.py: -------------------------------------------------------------------------------- 1 | # The write_stream method newly supported in Streamlit does not seem to be usable with Haystack's generator 2 | # So we will use the StreamlitCallbackHandler to stream the responses from the assistant to the UI 3 | 4 | # This is adapted from Langchain's StreamlitCallbackHandler 5 | # https://api.python.langchain.com/en/latest/_modules/langchain_community/callbacks/streamlit/streamlit_callback_handler.html#StreamlitCallbackHandler 6 | 7 | from haystack.dataclasses import StreamingChunk 8 | 9 | class StreamlitCallbackHandler(): 10 | def __init__(self, response_container): 11 | self.response_container = response_container 12 | self.current_text = '' 13 | 14 | # Stream the messages from the assistant to the UI 15 | def on_llm_new_token(self, chunk: StreamingChunk): 16 | # Only chat messages from the assistant are shown, because chunks from function/tool calls do not have the content attribute 17 | self.current_text += chunk.content 18 | self.response_container.markdown(self.current_text) -------------------------------------------------------------------------------- /streamlit/utils/funcs/db_interactions.py: -------------------------------------------------------------------------------- 1 | # Use requests to get the data from the database 2 | import requests 3 | 4 | db_base_url = 'http://127.0.0.1:5000' 5 | 6 | def get_categories(): 7 | response = requests.get(f'{db_base_url}/category') 8 | data = response.json() 9 | return data 10 | 11 | def get_items(ids=None,categories=None): 12 | params = { 13 | 'id': ids, 14 | 'category': categories, 15 | } 16 | response = requests.get(f'{db_base_url}/item', params=params) 17 | data = response.json() 18 | return data 19 | 20 | def purchase_item(id,quantity): 21 | 22 | headers = { 23 | 'Content-type':'application/json', 24 | 'Accept':'application/json' 25 | } 26 | 27 | data = { 28 | 'id': id, 29 | 'quantity': quantity, 30 | } 31 | response = requests.post(f'{db_base_url}/item/purchase', json=data, headers=headers) 32 | print(response) 33 | print(response.text) 34 | response_json = response.json() 35 | return response_json -------------------------------------------------------------------------------- /streamlit/utils/funcs/rag_pipeline.py: -------------------------------------------------------------------------------- 1 | from haystack import Pipeline, Document 2 | from haystack.document_stores.in_memory import InMemoryDocumentStore 3 | from haystack.components.writers import DocumentWriter 4 | from haystack.components.embedders import (SentenceTransformersDocumentEmbedder, SentenceTransformersTextEmbedder) 5 | from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever 6 | from haystack.components.builders import PromptBuilder 7 | from haystack.components.generators import OpenAIGenerator 8 | from haystack.utils import Secret 9 | 10 | # Embed documents 11 | def embed_documents(documents): 12 | document_store = InMemoryDocumentStore() 13 | 14 | indexing_pipeline = Pipeline() 15 | indexing_pipeline.add_component( 16 | "doc_embedder", SentenceTransformersDocumentEmbedder(model="sentence-transformers/all-MiniLM-L6-v2") 17 | ) 18 | indexing_pipeline.add_component("doc_writer", DocumentWriter(document_store=document_store)) 19 | 20 | indexing_pipeline.connect("doc_embedder.documents", "doc_writer.documents") 21 | 22 | indexing_pipeline.run({"doc_embedder": {"documents": documents}}) 23 | 24 | return document_store 25 | 26 | documents = [ 27 | Document(content="Coffee shop opens at 9am and closes at 5pm."), 28 | Document(content="Gym room opens at 6am and closes at 10pm.") 29 | ] 30 | 31 | document_store = embed_documents(documents) 32 | 33 | # Create RAG pipeline 34 | template = """ 35 | Answer the questions based on the given context. 36 | 37 | Context: 38 | {% for document in documents %} 39 | {{ document.content }} 40 | {% endfor %} 41 | Question: {{ question }} 42 | Answer: 43 | """ 44 | rag_pipe = Pipeline() 45 | rag_pipe.add_component("embedder", SentenceTransformersTextEmbedder(model="sentence-transformers/all-MiniLM-L6-v2")) 46 | rag_pipe.add_component("retriever", InMemoryEmbeddingRetriever(document_store=document_store)) 47 | rag_pipe.add_component("prompt_builder", PromptBuilder(template=template)) 48 | # Note to llm: We are using OpenAIGenerator, not the OpenAIChatGenerator, because the latter only accepts List[str] as input and cannot accept prompt_builder's str output 49 | rag_pipe.add_component("llm", OpenAIGenerator(api_key=Secret.from_env_var("OPENROUTER_API_KEY"), 50 | api_base_url="https://openrouter.ai/api/v1", 51 | model="openai/gpt-4-turbo-preview")) 52 | 53 | rag_pipe.connect("embedder.embedding", "retriever.query_embedding") 54 | rag_pipe.connect("retriever", "prompt_builder.documents") 55 | rag_pipe.connect("prompt_builder", "llm") 56 | 57 | def rag_pipeline_func(query: str): 58 | result = rag_pipe.run({"embedder": {"text": query}, "prompt_builder": {"question": query}}) 59 | 60 | return {"reply": result["llm"]["replies"][0]} 61 | --------------------------------------------------------------------------------