added all the files

.env

@@ -0,0 +1,3 @@
+NEBIUS_API_KEY = "eyJhbGciOiJIUzI1NiIsImtpZCI6IlV6SXJWd1h0dnprLVRvdzlLZWstc0M1akptWXBvX1VaVkxUZlpnMDRlOFUiLCJ0eXAiOiJKV1QifQ.eyJzdWIiOiJnb29nbGUtb2F1dGgyfDExMDgzMjI4NDU1OTcyMzc4OTEyMyIsInNjb3BlIjoib3BlbmlkIG9mZmxpbmVfYWNjZXNzIiwiaXNzIjoiYXBpX2tleV9pc3N1ZXIiLCJhdWQiOlsiaHR0cHM6Ly9uZWJpdXMtaW5mZXJlbmNlLmV1LmF1dGgwLmNvbS9hcGkvdjIvIl0sImV4cCI6MTkwNjgyMzA1OCwidXVpZCI6IjNmOTliMDMxLWRkNjUtNGYyMS1iZDE0LWViMTQyOTU0Nzg1MCIsIm5hbWUiOiJoYWNrYXRob24iLCJleHBpcmVzX2F0IjoiMjAzMC0wNi0wNFQxNzowNDoxOCswMDAwIn0.mJ1D7AFDdpRnsPDTk14xR0KSP_ND2cUA8DUuR3GevEk"
+QDRANT_API_KEY = "EvKLIIodeepwz9P8WGsIAGnYgPVKmoIce9oaoxT65lA9G9MCa6keyQ"
+QDRANT_URL = "https://2d9a7822-188b-4f81-ae14-b1c0fd4fbc6f.us-east4-0.gcp.cloud.qdrant.io:6333/"

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.db filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+hackathon_venv
+*__pycache__

agno_kb.py

@@ -0,0 +1,83 @@
+import os
+import json
+from pathlib import Path
+from dotenv import load_dotenv
+from agno.embedder.openai import OpenAIEmbedder
+from agno.knowledge.pdf import PDFKnowledgeBase, PDFReader
+from agno.vectordb.qdrant import Qdrant
+from agno.document.chunking.fixed import FixedSizeChunking
+
+# Load environment variables
+load_dotenv()
+
+QDRANT_URL = os.getenv("QDRANT_URL")
+QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
+
+# embeddings = OpenAIEmbedder(
+#     id="text-embedding-3-large",
+#     dimensions=3072,
+#     api_key=os.getenv("OPENAI_API_KEY")
+# )
+
+embeddings = OpenAIEmbedder(
+    id="BAAI/bge-en-icl",
+    dimensions=4096,
+    api_key=os.getenv("NEBIUS_API_KEY"),
+    base_url="https://api.studio.nebius.com/v1/"
+)
+
+
+class AgnoKnowledgeBase:
+    def __init__(self, query: str, user_id: str, thread_id: str, agno_kb_config: dict,
+                 chunk_size: int = 1000, num_documents: int = 6):
+        self.query = query
+        self.user_id = user_id
+        self.thread_id = thread_id
+        self.agno_kb_config = agno_kb_config
+        self.chunk_size = chunk_size
+        self.num_documents = num_documents
+
+    def setup_knowledge_base(self):
+        print(self.agno_kb_config)
+        agno_kb_config = self.agno_kb_config['knowledge_base']
+        input_data = agno_kb_config.get("input_data", {})
+        sources = input_data.get("source", [])
+        recreate = agno_kb_config.get("recreate", False)
+        collection_name = agno_kb_config.get("collection_name")
+        chunk_size = agno_kb_config.get("chunk_size")
+        overlap = agno_kb_config.get("overlap")
+        num_documents = agno_kb_config.get("num_documents")
+        chunking_strategy_type = agno_kb_config.get("chunking_strategy", "fixed")
+
+        if chunking_strategy_type == "fixed":
+            chunking_strategy = FixedSizeChunking(chunk_size=chunk_size, overlap=overlap)
+        else:
+            raise ValueError(f"Unsupported chunking strategy: {chunking_strategy_type}")
+
+        vector_db = Qdrant(
+            collection=collection_name,
+            embedder=embeddings,
+            url=QDRANT_URL,
+            api_key=QDRANT_API_KEY
+        )
+
+        for source in sources:
+            paths = source.get("path", [])
+            for path in paths:
+                print(f"Loading PDF into Qdrant: {path}")
+                knowledge_base = PDFKnowledgeBase(
+                    path=path,
+                    vector_db=vector_db,
+                    reader=PDFReader(),
+                    chunking_strategy=chunking_strategy,
+                    num_documents=num_documents
+                )
+                knowledge_base.load(recreate=recreate)
+
+        return PDFKnowledgeBase(
+            path=None,
+            vector_db=vector_db,
+            reader=PDFReader(),
+            chunking_strategy=chunking_strategy,
+            num_documents=num_documents
+        )

dynamic_agent.py

@@ -0,0 +1,76 @@
+import os
+import traceback
+from dotenv import load_dotenv
+from agno.agent import Agent
+from agno.storage.agent.sqlite import SqliteAgentStorage
+from agno.memory.agent import AgentMemory
+from agno.models.nebius import Nebius
+
+load_dotenv()
+NEBIUS_API_KEY = os.getenv("NEBIUS_API_KEY")
+DB_NAME = "hackathon.db"
+
+storage = SqliteAgentStorage(table_name="hackathon_storage", db_file=DB_NAME)
+memory = AgentMemory()
+
+class AgentFactory:
+    def __init__(self, user_id, thread_id, agent_config: dict, knowledge_base):
+        self.user_id = user_id
+        self.thread_id = thread_id
+        self.agent_config = agent_config
+        self.knowledge_base = knowledge_base
+
+    async def routing_agent(self):
+        try:
+            routing_agent = Agent(
+                    model=Nebius(
+                        id="meta-llama/Meta-Llama-3.1-405B-Instruct",
+                        temperature=0,
+                        api_key=NEBIUS_API_KEY,
+                        base_url="https://api.studio.nebius.com/v1/"
+                    ),
+                    name="Routing Agent",
+                    description="You are a helpful routing assistant. This agent is responsible for routing the user's message to the appropriate agent. Based on the question it has to provide response. If question relates to 'plot', 'chart', 'graph', 'visualize', 'visualization', 'visual','bar chart', 'line chart', 'pie chart', 'scatter plot', 'histogram', 'heatmap', 'dashboard', 'show me', 'display', 'draw', 'create chart','generate plot', 'make graph', 'data visualization', 'analytics','trends', 'comparison chart', 'infographic'. If the question relates to the visualization like above key points then respond with 'visualization' else respond 'normal'.",
+                    instructions=[
+                        "You should only respond with 'normal' or 'visualization'.",
+                        "DO NOT add any delimiter between the response and the word 'normal' or 'visualization'.",
+                        "Your response should be one word accordingly.",
+                    ],
+                    show_tool_calls=True,
+                    markdown=True,
+                    debug_mode=True
+                )
+            return routing_agent
+        except Exception as e:
+            print("Error creating routing agent:", traceback.format_exc())
+            raise e
+    
+    async def normal_and_reasoning_agent(self, tools, model_name) -> Agent:
+        try:
+            agent = Agent(
+                model=Nebius(
+                    id=model_name, #meta-llama/Meta-Llama-3.1-405B-Instruct #Qwen/Qwen3-235B-A22B #Qwen/Qwen3-30B-A3B
+                    temperature=0,
+                    api_key=NEBIUS_API_KEY,
+                    base_url="https://api.studio.nebius.com/v1/"
+                ),
+                name=self.agent_config["name"],
+                description=self.agent_config["description"],
+                instructions=self.agent_config["instructions"],
+                tools=tools,
+                show_tool_calls=True,
+                markdown=True,
+                debug_mode=True,
+                knowledge=self.knowledge_base,
+                search_knowledge=True,
+                storage=storage,
+                memory=memory,
+                user_id=self.user_id,
+                add_history_to_messages=True,
+                session_id=self.thread_id,
+                num_history_responses=10
+            )
+            return agent
+        except Exception as e:
+            print("Error creating agent:", traceback.format_exc())
+            raise e

flipkart_mobiles.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98d3d1aaac70b4be7da0ca79f57b4e0863d004a50710a092ffa8a12a6ff62b9a
+size 159744

mcp_tools.py

@@ -0,0 +1,203 @@
+import gradio as gr
+import sqlite3
+import traceback
+import os
+import re
+import uuid
+from agno.tools import tool
+import pandas as pd
+from matplotlib import pyplot as plt
+import seaborn as sns
+import plotly.express as px
+
+# --- DB Functions ---
+def init_product_db():
+    conn = sqlite3.connect("flipkart_mobiles.db")
+    cursor = conn.cursor()
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS mobiles (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            brand TEXT,
+            color TEXT,
+            model TEXT,
+            memory TEXT,
+            storage TEXT,
+            rating REAL,
+            selling_price REAL,
+            original_price REAL
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+def read_products():
+    conn = sqlite3.connect("flipkart_mobiles.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT * FROM mobiles")
+    rows = cursor.fetchall()
+    conn.close()
+    return rows
+
+# --- Tool Wrappers ---
+DB_PATH = "flipkart_mobiles.db"
+TABLE_NAME = "mobiles"
+
+@tool(show_result=True, stop_after_tool_call=True)
+def get_columns_info_from_database(columns: str = "*"):
+    """
+    Database Schema: brand, color, model, memory, storage, rating, selling_price, original_price
+    Table: mobiles
+
+    Query the 'mobiles' table selecting specified columns dynamically.
+    
+    Input:
+    - columns: a comma-separated string of column names to select, e.g. "brand, model, rating"
+      If "*", selects all columns.
+    
+    Returns:
+    - Formatted string of rows with selected columns.
+    """
+    if columns.strip() != "*":
+        if not re.fullmatch(r"[a-zA-Z0-9_,\s]+", columns):
+            return "Invalid columns format."
+
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    # Build query string dynamically
+    query = f"SELECT {columns} FROM {TABLE_NAME}"
+
+    try:
+        cursor.execute(query)
+        rows = cursor.fetchall()
+
+        # Get column names from cursor description
+        col_names = [desc[0] for desc in cursor.description]
+
+        output_lines = []
+        for row in rows:
+            row_dict = dict(zip(col_names, row))
+            formatted_row = ", ".join(f"{col}: {row_dict[col]}" for col in col_names)
+            output_lines.append(formatted_row)
+
+        return "\n".join(output_lines) if output_lines else "No rows found."
+    except Exception as e:
+        return f"Query error: {str(e)}"
+    finally:
+        conn.close()
+
+@tool(show_result=True, stop_after_tool_call=True)
+def generate_python_code(python_code: str) -> str:
+    """
+    You are a Python data scientist. Take the table and columns information from the chat history or agent memory.
+
+    Your task is to generate a valid Python script from the following response.
+    This table and columns information can be in raw English or structured format from the chat history or agent memory like:
+    - user: task - description
+    - tabular strings
+    - JSON-like text
+    - general descriptive statistics
+
+    You must:
+    1. Convert the data into a pandas DataFrame (use variable name `df`)
+    2. Select an appropriate chart (bar chart, pie chart, line chart, etc.) based on the user's query
+    3. Use matplotlib, seaborn, or plotly to plot. Any one of it to create the chart or graph or plot
+    4. Save the chart using the variable `image_path` to a PNG file
+    5. Return only the Python code — no comments, no markdown
+
+    ### Rules:
+    - Do not use `plt.show()` or any GUI renderer
+    - Use clear axis labels and title
+    - Save the figure using `plt.savefig(image_path)`
+    - `df` must be used for all data manipulations
+    - You must generate the full Python code block
+    - execute that Python code and return the path to the saved image folder.
+    - Create an image into the "plots" folder.
+
+    Example code:
+        ```python
+        import pandas as pd
+        import matplotlib.pyplot as plt
+
+        data = [
+            {"id": 1, "name": "Alice", "task": "NLP"},
+            {"id": 2, "name": "Bob", "task": "Vision"},
+            {"id": 3, "name": "Alice", "task": "NLP"}
+        ]
+
+        df = pd.DataFrame(data)
+        task_counts = df["task"].value_counts()
+
+        plt.figure(figsize=(6, 4))
+        task_counts.plot(kind="bar", color="skyblue")
+        plt.xlabel("Task")
+        plt.ylabel("Count")
+        plt.title("Task Distribution")
+        plt.savefig(image_path)
+        ```
+    """
+    return python_code
+
+@tool(show_result=True, stop_after_tool_call=True)
+def visualization_tool(python_code: str) -> str:
+    """ This function is for taking the python code as input from chat history or agent memory and cleaning it accordingly so that it can be executed, then executing it and returning the image path.
+    """
+    try:
+        cleaned_code = re.sub(r"^```(?:python)?|```$", "", python_code.strip(), flags=re.MULTILINE)
+        image_path = f"plots/{uuid.uuid4().hex}.png"
+        os.makedirs("plots", exist_ok=True)
+        exec_context = {
+            "pd": pd,
+            "plt": plt,
+            "sns": sns,
+            "px": px,
+            "image_path": image_path
+        }
+        exec(cleaned_code, exec_context)
+        return image_path
+    except Exception:
+        return f"Error executing visualization code:\n{traceback.format_exc()}"
+
+# --- Init DB ---
+init_product_db()
+
+# --- Define Toolkit ---
+toolkit = [
+    get_columns_info_from_database,
+    generate_python_code,
+    visualization_tool
+]
+
+# --- Gradio UI ---
+tabbed = gr.TabbedInterface(
+    interface_list=[
+        gr.Interface(
+            fn=get_columns_info_from_database.entrypoint,
+            inputs=[
+                gr.Textbox(label="Columns (comma separated, or * for all)", value="*")
+            ],
+            outputs=gr.Textbox(label="Query Result"),
+            title="Query Products"
+        ),
+        gr.Interface(
+            fn=generate_python_code.entrypoint,
+            inputs=[
+                gr.Textbox(label="Python code for Visualization", lines=10)
+            ],
+            outputs=gr.Textbox(label="Python Code for Visualization"),
+            title="Python Code Generation"
+        ),
+        gr.Interface(
+            fn=visualization_tool.entrypoint,
+            inputs=[
+                gr.Textbox(label="Visualization", lines=10)
+            ],
+            outputs=gr.Textbox(label="Saved Image Path"),
+            title="Auto Visualization"
+        )
+    ],
+    tab_names=["Query Products", "Python Code Generation", "Auto Visualization"]
+)
+
+# tabbed.launch(mcp_server=True)
+tabbed.launch(server_port=7863, mcp_server=True)