Initial Commit

__init__.py

@@ -0,0 +1,2 @@
+from utils import client, llm
+from data_section import data_bifercation

app.py

@@ -0,0 +1,182 @@
+from math import ceil
+from config import settings
+from mongoengine import connect
+from llm_agent import ReactAgent
+from fastapi import FastAPI, Response
+from chat import (
+    ChatSession,
+    FeedbackRequest,
+    LikeDislikeRequest,
+    UpdateSessionNameRequest,
+    Message,
+    ChatSessionSchema,
+    Role,
+)
+
+
+app = FastAPI()
+react_agent = ReactAgent()
+
+
+@app.on_event("startup")
+async def load_scheduler_and_DB():
+    connect(settings.DB_NAME, host=settings.DB_URI, alias="default")
+    print("Database connection established!!")
+
+
+@app.post("/query", tags=["Chat-Model"])
+def handle_query(chat_schema: ChatSessionSchema):
+    if chat_schema.session_id:
+        chat_session = ChatSession.objects(id=chat_schema.session_id)
+        chat_session = chat_session.first()
+
+        chat_history = chat_session.get_last_messages()
+        response = react_agent.handle_query(
+            session_id=chat_schema.session_id,
+            query=chat_schema.query,
+            chat_history=chat_history,
+        )
+
+        chat_session.add_message_with_metadata(
+            role=Role.USER.value, content=chat_schema.query
+        )
+        chat_session.add_message_with_metadata(role=Role.MODEL.value, content=response)
+
+    return {"response": response}
+
+
+@app.post(
+    "/temp_session",
+    tags=["Chat-Session"],
+)
+def temp_session() -> dict:
+    session = ChatSession()
+    session.save()
+    return {"message": "Session created", "session_id": session.get_id()}
+
+
+@app.post("/feedback", tags=["Chat-Features"])
+def feedback(feedback_request: FeedbackRequest):
+    chat_session = ChatSession.objects.get(id=feedback_request.session_id)
+    if chat_session:
+        chat_session.feedback_message(
+            feedback_request.message_id, feedback_request.feedback
+        )
+        return {"message": "Feedback saved successfully"}
+    else:
+        return Response(
+            content="Chat session not found", status_code=404, media_type="text/plain"
+        )
+
+
+@app.post("/like", tags=["Chat-Features"])
+def like_message(like_request: LikeDislikeRequest):
+    chat_session = ChatSession.objects.get(id=like_request.session_id)
+    if chat_session:
+        chat_session.like_message(like_request.message_id)
+        return {"message": "Message liked successfully"}
+    else:
+        return Response(
+            content="Chat session not found", status_code=404, media_type="text/plain"
+        )
+
+
+@app.post("/dislike", tags=["Chat-Features"])
+def dislike_message(dislike_request: LikeDislikeRequest):
+    chat_session = ChatSession.objects.get(id=dislike_request.session_id)
+    if chat_session:
+        chat_session.dislike_message(dislike_request.message_id)
+        return {"message": "Message disliked successfully"}
+    else:
+        return Response(
+            content="Chat session not found", status_code=404, media_type="text/plain"
+        )
+
+
+@app.post(
+    "/session_name_change",
+    tags=["Chat-Session"],
+)
+def update_session_name(request: UpdateSessionNameRequest):
+    try:
+        chat_session = ChatSession.objects(id=request.session_id).first()
+        if not chat_session:
+            return Response(
+                content="Session not found", status_code=404, media_type="text/plain"
+            )
+
+        chat_session.session_name = request.new_session_name
+        chat_session.save()
+
+        return {"message": "Session name updated successfully"}
+    except Exception:
+        return Response(
+            content="Session not found", status_code=404, media_type="text/plain"
+        )
+
+
+@app.get(
+    "/chat_session/<session_id>",
+    tags=["Chat-Session"],
+)
+def get_chat_session(
+    session_id: str,
+    page: int = 1,
+    size: int = 20,
+):
+    try:
+        chat_session = ChatSession.objects.get(id=session_id)
+    except BaseException:
+        return Response(
+            content="Chat session not found", status_code=404, media_type="text/plain"
+        )
+    skip = (page - 1) * size
+    message_ids = [
+        message.id for message in chat_session.messages[skip : skip + size]  # noqa
+    ]
+    messages = Message.objects(id__in=message_ids)
+    serialized_messages = [
+        {
+            **message.to_mongo().to_dict(),
+            "_id": str(message.id),
+            "chat_session": (
+                str(message.chat_session.id) if message.chat_session else None
+            ),
+        }
+        for message in messages
+    ]
+
+    total_count = ChatSession.objects.get(id=session_id).count()
+    total_pages = ceil(total_count / size)
+    has_next_page = page < total_pages
+    next_page = page + 1 if has_next_page else None
+
+    return {
+        "total_count": total_count,
+        "total_pages": total_pages,
+        "has_next_page": has_next_page,
+        "next_page": next_page,
+        "messages": serialized_messages,
+    }
+
+
+@app.delete(
+    "/delete_session",
+    tags=["Chat-Session"],
+)
+def delete_session(session_id: str):
+    try:
+        chat_session = ChatSession.objects(id=session_id).first()
+        if not chat_session:
+            return Response(
+                content="Chat session not found",
+                status_code=404,
+                media_type="text/plain",
+            )
+
+        chat_session.delete()
+        return {"message": "Session deleted successfully"}
+    except Exception:
+        raise Response(
+            content="Chat session not found", status_code=404, media_type="text/plain"
+        )

config.py

@@ -0,0 +1,23 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class Settings(BaseSettings):
+    NGROK_URL: str = os.environ.get("NGROK_URL", "FAKE")
+    MODEL_NAME: str = os.environ.get("MODEL_NAME", "FAKE")
+    DB_URI: str = os.environ.get("DB_URI", "FAKE")
+    DB_NAME: str = os.environ.get("DB_NAME", "FAKE")
+    BASE_URL: str = os.environ.get("BASE_URL", "FAKE")
+    ORIGIN: str = os.environ.get("ORIGIN", "FAKE")
+    COOKIE: str = os.environ.get("COOKIE", "FAKE")
+    STORE_ID: str = os.environ.get("STORE_ID", "FAKE")
+    BRAND_ID: str = os.environ.get("BRAND_ID", "FAKE")
+    PHONE_NUMBER_ID: str = os.environ.get("PHONE_NUMBER_ID", "FAKE")
+    BEARER_TOKEN: str = os.environ.get("BEARER_TOKEN", "FAKE")
+    model_config = SettingsConfigDict(env_file=".env")
+
+
+settings = Settings()

context.py

@@ -0,0 +1,88 @@
+from datetime import datetime
+from utils import client
+from config import settings
+
+
+def ollama_context_query(chat_history, user_query):
+    print(user_query)
+    prompt = f"""You are a Contextualisation engine for a Restaurant Order Bot. Your role is to rewrite the user's natural language query so that it is optimized for the relevant tool processing without changing its original intent. Always ensure that the context from previous interactions is utilized, but avoid generating long or unnecessary context queries. Keep the response minimal and concise.
+
+    IMPORTANT:
+    - **NEVER** alter the meaning or context of the user's query.
+    - **Minimize the query** whenever possible, focusing only on the essential parts required for tool processing.
+    - **Keep context queries as short as possible** and never generate long or redundant queries.
+
+    You have the following tools available:
+    - 'MenuTool': For menu-related queries like available dishes, specials, or recommendations.
+    - 'CartTool': For managing cart operations such as adding, removing, or viewing items.
+    - 'OrderTool': For placing orders or checking out.
+
+    GUIDELINES:
+    1. **Menu-Related Queries**: When the user asks about menu items (e.g., 'What can I have for lunch?','What are the katsu items?', 'Can I see the breakfast menu?', 'What’s in the combo meal?', 'What’s the price for the burger?'), route the query to the MenuTool. Ensure the suggestions are current and relevant to the user's preferences.
+    2. **Cart Operations**: For queries about cart management (e.g., 'add to cart', 'remove from cart', or 'view cart'), route them to the CartTool. Reference previous cart interactions when necessary.
+    - Example: "add 2 quantity of Mango Kani Salad" → `CartTool`: "add 2 quantity of Mango Kani Salad".
+    - Example: "I would like Vegetable Spring Rolls" → `CartTool`: "add 1 quantity of Vegetable Spring Rolls".
+    - Example: ""I’ll take a burger." → `CartTool`: "add 1 quantity of burger".
+    - Example: ""Could you put five servings of lemon chicken in my cart?" → `CartTool`: "add 5 quantity of lemon chicken".
+    3. **Order and Checkout Queries**: For queries about order placement or checkout, route them to the OrderTool. Break down complex queries where multiple operations are involved.
+    - Example: "add 2 quantity of Mango Kani Salad and place order" should result in:
+        - `CartTool`: "add 2 quantity of Mango Kani Salad".
+        - `OrderTool`: "place order".
+    4. **Multiple Tools in One Query**: When a query involves multiple operations, split it into separate tool calls for clarity.
+    - Example: "remove the Mango Kani Salad from the cart and checkout" →
+        - `CartTool`: "remove Mango Kani Salad".
+        - `OrderTool`: "checkout".
+    5. **If a query involves tool utilization, return the tool name only (e.g., 'MenuTool', 'CartTool', 'OrderTool').**
+    6. **Do not return long contextual information**; focus on minimal and clear context queries that directly relate to the tool's operation.
+    7. If the quantity is not defined while calling the cart tool, then rearrange the sentence to include the quantity as one.
+    8. If no tool utilization is required, respond naturally and suggest more specific questions about the restaurant's offerings.
+    9. Convert any date information to the format YYYY-MM-DD.
+    10. If asked 'Who are you?', respond with 'I am SAHL order bot.'
+    11. Always use previous chat history between the user and assistant for continuity, but DO NOT include chat history in the response.
+    12. If the cart tool is utilized and the user's response doesn't contain any item name, then use the previous history to include the item name.
+
+    Use the above guidelines to generate context, ensuring you maintain the meaning and intent of the user’s query without introducing unnecessary complexity or length.
+    NOTE: The current date and time is: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n
+    PREVIOUS CHAT HISTORY: {chat_history} Use the chat history to inform your response. Reference relevant previous user inputs or interactions to maintain context, continuity, and coherence. When providing a response, ensure it builds on past conversations and avoids unnecessary repetition, while addressing any new information or questions introduced by the user.\n
+    Use the above chat history to generate the context, but do not include it in the response."""
+
+    system_msg = {"role": "system", "content": prompt}
+    user_msg = {"role": "user", "content": user_query}
+    response = client.chat(
+        model=settings.MODEL_NAME,
+        messages=[system_msg, user_msg],
+    )
+    context_query = response["message"]["content"]
+    print("CONTEXT .... ")
+    print(context_query)
+    if any(tool in context_query for tool in ["MenuTool", "CartTool", "OrderTool"]):
+        return context_query, True
+
+    print("check this contexyt query in your terminal ::::::::::::: " * 5, context_query)
+    return context_query, False
+
+
+def summarised_output(messages, chat_history, context_query, user_query):
+    prompt = (
+        "You are a summarization engine. Your role is to merge multiple tool responses related to Restaurant Order  into a simplified and concise response for the user.\n"
+        "IMPORTANT:\n"
+        "- Only use the information provided by the tools and the user's query; do not add any extra information from your end.\n"
+        "- Merge the responses into a simplified format, making it easy for the customer to understand.\n"
+        "- Always show numbers clearly if provided in the tool response (e.g., '2 items added to cart', 'Order total is 150 Dirhams').\n"
+        "- Avoid adding unnecessary context or extra phrases. Just focus on providing the relevant information in a clear manner.\n"
+        "- If the response contains lists of items or details, format them neatly for readability.\n"
+        "- For long answers, if all the information is relevant, provide it in full, but ensure it's simplified and concise.\n"
+        "- Ignore unnecessary or irrelevant information from the tool responses to ensure that only what is important for the customer is shown.\n"
+        "- If the orderId is present in the tool's response, then always include this orderId in the summarization.\n\n"
+        f"PREVIOUS CHAT HISTORY: {chat_history}\n"
+        f"CURRENT TOOL RESPONSES: {messages}\n"
+        f"CONTEXTUALIZATION QUERY: {context_query}\n"
+    )
+    system_msg = {"role": "system", "content": prompt}
+    user_msg = {"role": "user", "content": user_query}
+    response = client.chat(
+        model=settings.MODEL_NAME,
+        messages=[system_msg, user_msg],
+    )
+    summarized_response = response["message"]["content"]
+    return summarized_response

data_section.py

@@ -0,0 +1,20 @@
+from tools.menu_tools_utils import get_data_store_id
+from config import settings
+
+def data_bifercation(store_id, brand_id):
+    data = get_data_store_id(settings.STORE_ID, settings.BRAND_ID).get("data")
+    category = {}
+    items = {}
+    main_data = []
+    for cate in data:
+        print("----"*30)
+        for item in cate.get("itemsData"):
+            inner_data = []
+            inner_data.append(cate.get("name"))
+            inner_data.append(item.get("title"))
+            inner_data.append(item.get("price"))
+            items[item.get("title")] = item.get("_id")
+            main_data.append(inner_data)
+        category[cate.get("name").lower().strip()] = cate.get("_id")
+        print("----"*30)
+    return main_data, category, items

llm_agent.py

@@ -0,0 +1,190 @@
+from tools import MenuTool, CartTool, OrderTool, greetings_function
+from data_section import data_bifercation
+from tools.prompts import tool_prompt_function
+from config import settings
+from utils import client
+from context import ollama_context_query, summarised_output
+import pandas as pd
+
+
+class ReactAgent:
+    def __init__(self):
+        self.store_id = "66dff7a04b17303d454d4bbc"
+        self.brand_id = "66cec85093c5b0896c9125c5"
+        columns = ["category", "item", "price"]
+        main_data, category, items = data_bifercation(self.store_id, self.brand_id)
+
+        self.items = items
+        self.category = category
+
+        df = pd.DataFrame(main_data)
+        df.columns = columns
+        df["item"] = df["item"].str.lower()
+        df["category"] = df["category"].str.lower()
+
+        self.df = df
+        self.menu_tool = MenuTool(df)
+        self.cart_tool = CartTool(df)
+        self.order_tool = OrderTool(df)
+        self.llm_client = client
+
+    def handle_query(self, session_id, query, chat_history):
+
+        prompt = tool_prompt_function(current_query=query, session_id=session_id)
+
+        context_query, greet_bool = ollama_context_query(
+            chat_history=chat_history, user_query=query
+        )
+
+        if not greet_bool:
+            return greetings_function(query)
+
+        if context_query in ["MenuTool", "CartTool", "OrderTool"]:
+            user_message_content = query
+        else:
+            user_message_content = context_query
+
+        messages = [
+            {"role": "system", "content": prompt},
+            {"role": "user", "content": user_message_content},
+        ]
+
+        response = self.llm_client.chat(
+            model=settings.MODEL_NAME,
+            messages=messages,
+            tools=[
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "menu_tool",
+                        "description": "Fetch the restaurant menu based on user input",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "query": {
+                                    "type": "string",
+                                    "description": "User's natural language query for the menu",
+                                }
+                            },
+                            "required": ["query"],
+                        },
+                    },
+                },
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "cart_tool",
+                        "description": "Manage the cart based on user input (add/remove/view)",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "query": {
+                                    "type": "string",
+                                    "description": "User's cart query to add/remove/view items",
+                                },
+                                "session_id": {
+                                    "type": "string",
+                                    "description": "current session id",
+                                },
+                            },
+                            "required": ["query", "session_id"],
+                        },
+                    },
+                },
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "order_tool",
+                        "description": "Handle order and checkout functionality",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "query": {
+                                    "type": "string",
+                                    "description": "User's request to place an order",
+                                },
+                            },
+                            "required": ["query"],
+                        },
+                    },
+                },
+            ],
+        )
+
+        print("----" * 30)
+        print(query)
+        print("----" * 30)
+        print(response)
+        print("----" * 30)
+
+        tool_call = response["message"].get("tool_calls", [])
+        tool_calls = [
+            tool_call[i].get("function").get("name")
+            for i in range(0, len(response["message"].get("tool_calls", [])))
+        ]
+
+        print("----" * 30)
+        print(tool_call)
+        print("----" * 30)
+        print(tool_calls)
+        print("----" * 30)
+
+        tool_responses = []
+        for tool_name in tool_calls:
+            if tool_name == "menu_tool":
+                tool_call_index = next(
+                    (
+                        index
+                        for index, call in enumerate(tool_call)
+                        if call["function"]["name"] == "menu_tool"
+                    ),
+                    None,
+                )
+                tool_args = tool_call[tool_call_index]["function"]["arguments"]
+                response = self.menu_tool.run(tool_args["query"], session_id)
+                print("menu tool response :: ", response)
+                tool_responses.append(response)
+
+            elif tool_name == "cart_tool":
+                tool_call_index = next(
+                    (
+                        index
+                        for index, call in enumerate(tool_call)
+                        if call["function"]["name"] == "cart_tool"
+                    ),
+                    None,
+                )
+                tool_args = tool_call[tool_call_index]["function"]["arguments"]
+                response = self.cart_tool.run(tool_args["query"], session_id=session_id)
+                print("cart tool response :: ", response)
+                tool_responses.append(response)
+
+            elif tool_name == "order_tool":
+                tool_call_index = next(
+                    (
+                        index
+                        for index, call in enumerate(tool_call)
+                        if call["function"]["name"] == "order_tool"
+                    ),
+                    None,
+                )
+                tool_args = tool_call[tool_call_index]["function"]["arguments"]
+                print("order tool response :: ", response)
+                response = self.order_tool.run(
+                    df=self.df,
+                    session_id=session_id,
+                    category=self.category,
+                    items=self.items,
+                    store_id=self.store_id,
+                    brand_id=self.brand_id,
+                )
+                tool_responses.append(response)
+
+        combined_response = summarised_output(
+            messages=tool_responses,
+            chat_history=chat_history,
+            context_query=context_query,
+            user_query=query,
+        )
+
+        return combined_response

page.py

@@ -0,0 +1,191 @@
+import streamlit as st
+from chat import ChatSession, ChatSessionSchema, Role
+from app import react_agent
+from mongoengine import connect
+from config import settings
+import requests
+from tools.menu_tools_utils import get_data_store_id
+import speech_recognition as sr
+
+st.set_page_config(layout="wide")
+
+connect(settings.DB_NAME, host=settings.DB_URI, alias="default")
+print("Database connection established!!")
+
+
+def speech_to_text():
+    r = sr.Recognizer()
+    with sr.Microphone() as mic:
+        st.write("Listening for your query...")
+        r.adjust_for_ambient_noise(mic, duration=1)
+        audio = r.listen(mic)
+        try:
+            text = r.recognize_google(audio)
+            st.success(f"Recognized: {text}")
+            return text
+        except sr.UnknownValueError:
+            st.error("Sorry, I could not understand the audio.")
+            return ""
+        except sr.RequestError as e:
+            st.error(
+                f"Could not request results from Google Speech Recognition service; {e}"
+            )
+            return ""
+
+
+col1, col2 = st.columns([1, 3])
+
+with col2:
+    st.title("Restaurant Order Bot")
+
+    if "session_id" not in st.session_state:
+        session = ChatSession()
+        session.save()
+        st.session_state["session_id"] = str(session.id)
+
+    if "conversation" not in st.session_state:
+        st.session_state["conversation"] = []
+
+    # Input: Either type in or use the speech-to-text button
+    user_query = st.text_input("Ask something:")
+
+    col3, col4, col5 = st.columns([3, 3, 3])
+    # New button for speech recognition
+    with col3:
+        if st.button("🎤 Speak your query"):
+            recognized_text = speech_to_text()
+            if recognized_text:
+                user_query = recognized_text  # Set recognized text to the user input
+                st.session_state["conversation"].append(
+                    {"role": "user", "text": user_query}
+                )
+
+                chat_schema = ChatSessionSchema(
+                    session_id=st.session_state["session_id"], query=user_query
+                )
+                chat_session = ChatSession.objects(id=chat_schema.session_id).first()
+
+                chat_history = chat_session.get_last_messages()
+                response = react_agent.handle_query(
+                    session_id=chat_schema.session_id,
+                    query=chat_schema.query,
+                    chat_history=chat_history,
+                )
+
+                chat_session.add_message_with_metadata(
+                    role=Role.USER.value, content=chat_schema.query
+                )
+                chat_session.add_message_with_metadata(
+                    role=Role.MODEL.value, content=response
+                )
+                if response:
+                    st.session_state["conversation"].append(
+                        {"role": "bot", "text": response}
+                    )
+                else:
+                    st.session_state["conversation"].append(
+                        {
+                            "role": "bot",
+                            "text": "Error: Could not get a response from the server.",
+                        }
+                    )
+
+    # Submit button for text input
+    with col4:
+        if st.button("Submit"):
+            if user_query:
+                st.session_state["conversation"].append(
+                    {"role": "user", "text": user_query}
+                )
+
+                chat_schema = ChatSessionSchema(
+                    session_id=st.session_state["session_id"], query=user_query
+                )
+                chat_session = ChatSession.objects(id=chat_schema.session_id).first()
+
+                chat_history = chat_session.get_last_messages()
+                response = react_agent.handle_query(
+                    session_id=chat_schema.session_id,
+                    query=chat_schema.query,
+                    chat_history=chat_history,
+                )
+
+                chat_session.add_message_with_metadata(
+                    role=Role.USER.value, content=chat_schema.query
+                )
+                chat_session.add_message_with_metadata(
+                    role=Role.MODEL.value, content=response
+                )
+                if response:
+                    st.session_state["conversation"].append(
+                        {"role": "bot", "text": response}
+                    )
+                else:
+                    st.session_state["conversation"].append(
+                        {
+                            "role": "bot",
+                            "text": "Error: Could not get a response from the server.",
+                        }
+                    )
+    with col5:
+        if st.button("Clear Chat"):
+            st.session_state["conversation"] = []
+
+    # Display conversation
+    user_message_style = """
+        background-color: #d1e7dd;
+        padding: 10px;
+        border-radius: 10px;
+        margin-bottom: 10px;
+        color: #0f5132;
+        text-align: left;
+    """
+    bot_message_style = """
+        background-color: #f8d7da;
+        padding: 10px;
+        border-radius: 10px;
+        margin-bottom: 10px;
+        color: #842029;
+        text-align: left;
+    """
+
+    for message in st.session_state["conversation"]:
+        if message["role"] == "user":
+            st.markdown(
+                f"<div style='{user_message_style}'><strong>You:</strong> {message['text']}</div>",
+                unsafe_allow_html=True,
+            )
+        else:
+            st.markdown(
+                f"<div style='{bot_message_style}'><strong>Bot:</strong> {message['text']}</div>",
+                unsafe_allow_html=True,
+            )
+
+with col1:
+    st.title("Menu")
+    # store_id = "66dff7a04b17303d454d4bbc"
+    # brand_id = "66cec85093c5b0896c9125c5"
+    response = get_data_store_id(settings.STORE_ID, settings.BRAND_ID)
+    menu_data = response
+
+    blank_image_url = "https://via.placeholder.com/1x1/FFFFFF/FFFFFF"
+
+    with st.container():
+        if menu_data.get("success"):
+            for category in menu_data["data"]:
+                with st.expander(category["name"], expanded=False):
+                    for item in category.get("itemsData", []):
+                        try:
+                            img_url = item.get("img_url", None)
+                            if img_url:
+                                st.image(img_url, width=100)
+                            else:
+                                st.image(blank_image_url, width=100)
+                        except Exception as e:
+                            st.image(blank_image_url, width=100)
+
+                        st.write(f"**{item['title']}**: {item['price']} Dirham AED")
+                        st.write(item["description"])
+                        st.write("---")
+        else:
+            st.write("Failed to load menu data.")

requirements.txt

@@ -0,0 +1,16 @@
+fastapi
+uvicorn
+streamlit
+mongoengine
+requests
+pydantic
+ollama
+pydantic_settings
+openpyxl
+llama-index-experimental
+llama_index
+llama-index-llms-ollama
+spacy
+pycryptodome
+SpeechRecognition
+PyAudio

utils.py

@@ -0,0 +1,6 @@
+import ollama
+from config import settings
+from llama_index.llms.ollama import Ollama
+
+client = ollama.Client(host=settings.NGROK_URL)
+llm = Ollama(model=settings.MODEL_NAME, base_url=settings.NGROK_URL)