push

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY . .
+
+RUN apt-get update && apt-get install -y
+
+RUN pip install uv
+
+RUN uv sync
+
+EXPOSE 10000
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "10000"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rauhan Ahmed Siddiqui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

api/models.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+from enum import Enum
+
+class LikedOrFlagged(str, Enum):
+    liked = "liked"
+    flagged = "flagged"
+
+class WorkflowQuery(BaseModel):
+    query: str
+
+class FlagOutput(BaseModel):
+    query: str
+    response: str
+    flag: LikedOrFlagged
+    feedback: str | None = None

api/services.py

@@ -0,0 +1,30 @@
+from api.models import FlagOutput, WorkflowQuery
+from src.workflows.workflow import workflow
+from sqlalchemy import create_engine, text
+import os
+
+class FastAPIService:
+    def __init__(self):
+        self.engine = create_engine(
+            os.environ.get("POSTGRE_CONNECTION_STRING")
+        )
+    
+    def answerQuery(self, workflowQueryModel: WorkflowQuery) -> str:
+        return workflow.run(workflowQueryModel.query)
+    
+    def flagResponse(self, likedOrFlaggedModel: FlagOutput) -> str:
+        with self.engine.connect() as conn:
+            conn.execute(
+                text("""
+                    INSERT INTO feedback (query, response, flag, feedback)
+                    VALUES (:query, :response, :flag, :feedback)
+                """),
+                {
+                    "query": likedOrFlaggedModel.query,
+                    "response": likedOrFlaggedModel.response,
+                    "flag": likedOrFlaggedModel.flag,
+                    "feedback": likedOrFlaggedModel.feedback
+                }
+            )
+            conn.commit()
+        return "Data inserted successfully"

config.ini

@@ -0,0 +1,20 @@
+[SQLAGENT]
+modelName = zai-glm-4.6
+maxTokens = 512
+temperature = 0.5
+
+[RAGAGENT]
+denseEmbeddings = BAAI/bge-large-en-v1.5
+sparseEmbeddings = Qdrant/bm25
+modelName = llama-3.3-70b
+maxTokens = 1024
+temperature = 0.75
+
+[REASONINGAGENT]
+modelName = qwen-3-32b
+temperature = 0.6
+
+[SYNTHESIZERAGENT]
+modelName = gpt-oss-120b
+temperature = 0.6
+maxTokens = 1250

main.py

@@ -0,0 +1,24 @@
+from api.models import FlagOutput, WorkflowQuery
+from fastapi.exceptions import HTTPException
+from fastapi.responses import JSONResponse
+from api.services import FastAPIService
+from fastapi import FastAPI
+
+service = FastAPIService()
+app = FastAPI(title = "Agentic Data Pipeline Endpoints")
+
+@app.post("/answerQuery")
+async def answerQuery(queryModel: WorkflowQuery):
+    try:
+        response = service.answerQuery(workflowQueryModel = queryModel)
+        return JSONResponse(status_code = 200, content = {"response": response})
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = str(e))
+    
+@app.post("/flag")
+async def flagOutput(flagModel: FlagOutput):
+    try:
+        response = service.flagResponse(likedOrFlaggedModel = flagModel)
+        return JSONResponse(status_code = 200, content = {"response": response})
+    except Exception as e:
+        raise HTTPException(status_code = 500, detail = str(e))

notebooks/IndividualAgents.ipynb

@@ -0,0 +1,686 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "5S7i2sK0aXZf"
+      },
+      "outputs": [],
+      "source": [
+        "!pip install -qU langchain langchain-community langchain-cerebras sqlalchemy langchain-core langchain-qdrant fastembed langchain-huggingface langgraph langgraph"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0-H0yyHyioEV"
+      },
+      "source": [
+        "## SQL Agent"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "NuqpdoNTitWT"
+      },
+      "outputs": [],
+      "source": [
+        "from langchain_community.agent_toolkits.sql.toolkit import SQLDatabaseToolkit\n",
+        "from langchain_community.utilities.sql_database import SQLDatabase\n",
+        "from langchain_community.tools.sql_database.tool import (\n",
+        "    InfoSQLDatabaseTool,\n",
+        "    ListSQLDatabaseTool,\n",
+        "    QuerySQLCheckerTool,\n",
+        "    QuerySQLDatabaseTool,\n",
+        ")\n",
+        "from langchain_cerebras import ChatCerebras\n",
+        "from langchain.agents import create_agent\n",
+        "from sqlalchemy.pool import StaticPool\n",
+        "from sqlalchemy import create_engine\n",
+        "from langchain_classic import hub\n",
+        "import os\n",
+        "\n",
+        "\n",
+        "promptTemplate = hub.pull(\"langchain-ai/sql-agent-system-prompt\")\n",
+        "systemMessage = promptTemplate.format(dialect=\"PostgreSQL\", top_k=5)\n",
+        "\n",
+        "class PostgreSQLAgent:\n",
+        "    def __init__(self, connectionString: str) -> None:\n",
+        "        self.engine = create_engine(connectionString, poolclass = StaticPool)\n",
+        "        db = SQLDatabase(self.engine)\n",
+        "        llm = ChatCerebras(\n",
+        "            model = \"zai-glm-4.6\"\n",
+        "        )\n",
+        "        self.toolkit = SQLDatabaseToolkit(db = db, llm = llm)\n",
+        "        self.agent = create_agent(llm, self.toolkit.get_tools(), system_prompt=systemMessage)\n",
+        "\n",
+        "    def query(self, query) -> str:\n",
+        "        response = self.agent.invoke(\n",
+        "            {\"messages\": [(\"user\", query)]}\n",
+        "        )\n",
+        "        return response[\"messages\"][-1].content"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "paQ6BDQBcJa4"
+      },
+      "outputs": [],
+      "source": [
+        "pg = PostgreSQLAgent(os.environ.get(\"POSTGRE_CONNECTION_STRING\"))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 86
+        },
+        "id": "bBrhF6UHiS-J",
+        "outputId": "5897ab64-4127-48c0-9bac-67e668fff082"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "string"
+            },
+            "text/plain": [
+              "'\\nBased on the data from the database, the **AI Specialist** role offers the highest average salary at approximately **$120,571** per year.\\n\\nHere are the top 5 highest-paying job roles by average salary:\\n\\n1. **AI Specialist**: $120,571\\n2. **Machine Learning Engineer**: $118,828\\n3. **Head of AI**: $118,543\\n4. **AI Research Scientist**: $117,898\\n5. **AI Architect**: $117,437\\n\\nAll of the top-paying roles are in the artificial intelligence field, which reflects the high demand and specialized skills required for AI-related positions in the current job market.'"
+            ]
+          },
+          "execution_count": 4,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "pg.query(\"Which job role offers the highest average salary?\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "ncujGlUalxJe"
+      },
+      "source": [
+        "## RAG Agent"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {
+        "id": "N4FPEtxPwz4K"
+      },
+      "outputs": [],
+      "source": [
+        "from langchain_qdrant import FastEmbedSparse, RetrievalMode\n",
+        "from langchain_huggingface import HuggingFaceEmbeddings\n",
+        "from langchain_qdrant import QdrantVectorStore\n",
+        "\n",
+        "modelName = \"BAAI/bge-large-en-v1.5\"\n",
+        "modelKwargs = {'device': 'cpu'}\n",
+        "encodeKwargs = {'normalize_embeddings': True}\n",
+        "embeddings = HuggingFaceEmbeddings(\n",
+        "    model_name=modelName,\n",
+        "    model_kwargs=modelKwargs,\n",
+        "    encode_kwargs=encodeKwargs\n",
+        ")\n",
+        "\n",
+        "sparseEmbeddings = FastEmbedSparse(model_name=\"Qdrant/bm25\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {
+        "id": "UvuUKB3f2PUa"
+      },
+      "outputs": [],
+      "source": [
+        "ragTemplate = \"\"\"\n",
+        "You are an expert, fact-checking assistant. Your sole purpose is to answer the user's question.\n",
+        "\n",
+        "CONSTRAINTS:\n",
+        "1. **USE ONLY THE PROVIDED CONTEXT**. Do not use any prior knowledge or external information.\n",
+        "2. If the context does not contain the answer, you **MUST** respond with: \"I do not have enough information to answer the question based on the provided documents.\" DO NOT make up an answer.\n",
+        "3. Your answer must be **complete**, **accurate**, and directly address the user's question.\n",
+        "4. For every statement you make, cite the source document. For this exercise, assume the entire context can be from multiple sources, and please state **(Source: <content source from metadata of retrieved documents>)** at the end of the sentence or paragraph, but not the page number.\n",
+        "\n",
+        "CONTEXT:\n",
+        "{context}\n",
+        "\n",
+        "---\n",
+        "\n",
+        "QUESTION: {query}\n",
+        "\n",
+        "---\n",
+        "\n",
+        "FINAL ANSWER:\n",
+        "\"\"\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "jKnA_vkR0jgk"
+      },
+      "outputs": [],
+      "source": [
+        "from qdrant_client.http.models import Distance, VectorParams\n",
+        "from langchain_core.output_parsers import StrOutputParser\n",
+        "from langchain_core.runnables import RunnablePassthrough\n",
+        "from langchain_core.prompts import ChatPromptTemplate\n",
+        "from langchain_qdrant import QdrantVectorStore\n",
+        "from qdrant_client import QdrantClient\n",
+        "\n",
+        "class RAGAgent:\n",
+        "    def __init__(self) -> None:\n",
+        "        client = QdrantClient(\n",
+        "            url=os.environ.get(\"QDRANT_URL\"),\n",
+        "            api_key=os.environ.get(\"QDRANT_API_KEY\"),\n",
+        "        )\n",
+        "        vectorStore = QdrantVectorStore(\n",
+        "            client=client,\n",
+        "            collection_name=\"sampleCollection\",\n",
+        "            embedding=embeddings,\n",
+        "            vector_name=\"semantic-search\",\n",
+        "            sparse_vector_name=\"syntactic-search\",\n",
+        "            retrieval_mode=RetrievalMode.SPARSE,\n",
+        "            sparse_embedding=sparseEmbeddings\n",
+        "        )\n",
+        "        promptTemplate = ChatPromptTemplate.from_template(ragTemplate)\n",
+        "        retriever = vectorStore.as_retriever(search_kwargs = {\"k\": 5})\n",
+        "        llm = ChatCerebras(\n",
+        "            model = \"llama-3.3-70b\"\n",
+        "        )\n",
+        "        chain = {\"query\": RunnablePassthrough(), \"context\": RunnablePassthrough() | retriever} | promptTemplate | llm | StrOutputParser()\n",
+        "        self.chain = chain\n",
+        "\n",
+        "    def query(self, query) -> str:\n",
+        "        output = self.chain.invoke(query)\n",
+        "        return output"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "id": "9L69H_N_3c5k"
+      },
+      "outputs": [],
+      "source": [
+        "r = RAGAgent()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "id": "rPb4TZAg3eKt"
+      },
+      "outputs": [],
+      "source": [
+        "response = r.query(\"What is OOPM?\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "j5uvqtgb3hPW",
+        "outputId": "d1bbf872-9eb1-40f4-e405-309750c6fa3c"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "I do not have enough information to answer the question based on the provided documents. (Source: None)\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(response)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "SLwUbRA_4epj"
+      },
+      "source": [
+        "## Internet Search"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "5-hqVXaMV-TS"
+      },
+      "outputs": [],
+      "source": [
+        "from langchain_community.utilities import GoogleSerperAPIWrapper\n",
+        "\n",
+        "class InternetSearchAgent:\n",
+        "    def __init__(self) -> None:\n",
+        "        self.search = GoogleSerperAPIWrapper(serper_api_key=os.environ.get(\"SERPER_API_KEY\"))\n",
+        "\n",
+        "    def query(self, query) -> str:\n",
+        "        output = self.search.run(query)\n",
+        "        return output"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "c9ll1QRXbEUF"
+      },
+      "source": [
+        "## Reasoning Agent"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "metadata": {
+        "id": "8dLn7yvdbGfy"
+      },
+      "outputs": [],
+      "source": [
+        "reasoningTemplate = \"\"\"\n",
+        "You are the General Knowledge and Reasoning Agent. Your function is to provide clear, concise, and expert explanations of widely established academic concepts, definitions, and common-sense knowledge. You must rely exclusively on your core training data and internal knowledge.\n",
+        "\n",
+        "MANDATE:\n",
+        "\n",
+        "Answer factual, common knowledge, definition, or theoretical questions.\n",
+        "\n",
+        "CRITICAL REASONING STEP (CoT): For all problem-solving, analytical, or multi-part questions, you MUST perform the following internal steps:\n",
+        "a. Analyze: Carefully interpret the overall user problem and its objectives.\n",
+        "b. Breakdown: Decompose the problem into sequential, logical sub-parts.\n",
+        "c. Solve: Execute the necessary reasoning steps for each sub-part rigorously.\n",
+        "d. Synthesize: Combine the results into a single, cohesive, final answer.\n",
+        "\n",
+        "Provide structured, high-quality explanations, examples, and summaries.\n",
+        "\n",
+        "CONSTRAINTS (CRITICAL ANTI-HALLUCINATION RULES):\n",
+        "\n",
+        "DO NOT answer any question that requires accessing external, private, or real-time data. This includes but is not limited to: recent news, local weather, file content (RAG), specific company metrics (SQL), or any data more recent than your last training cutoff.\n",
+        "\n",
+        "IMMEDIATELY and EXCLUSIVELY respond with the exact phrase: \"Knowledge gap detected. This query requires external data access (RAG, SQL, or Web).\" if the answer is not already in your internal knowledge base.\n",
+        "\n",
+        "Ensure your response is clear, professional, and directly addresses the query.\n",
+        "\n",
+        "QUESTION: {query}\n",
+        "\"\"\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "vYhJVALTbGWX"
+      },
+      "outputs": [],
+      "source": [
+        "class ReasoningAgent:\n",
+        "    def __init__(self) -> None:\n",
+        "        promptTemplate = ChatPromptTemplate.from_template(reasoningTemplate)\n",
+        "        llm = ChatCerebras(\n",
+        "            model = \"qwen-3-32b\"\n",
+        "        )\n",
+        "        chain = {\"query\": RunnablePassthrough()} | promptTemplate | llm | StrOutputParser()\n",
+        "        self.chain = chain\n",
+        "\n",
+        "    def query(self, query) -> str:\n",
+        "        output = self.chain.invoke(query)\n",
+        "        return output"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "id": "ToygvML3cHBl"
+      },
+      "outputs": [],
+      "source": [
+        "r = ReasoningAgent()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "metadata": {
+        "id": "smNTW70tcJDK"
+      },
+      "outputs": [],
+      "source": [
+        "output = r.query(\"What is 34957 * 4035?\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 120
+        },
+        "id": "ChIOqnlMcpiI",
+        "outputId": "130a9cc6-6cfa-4015-d80a-64b4e2dd0dc7"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "string"
+            },
+            "text/plain": [
+              "\"<think>\\nOkay, let's see. The user is asking for the product of 34,957 and 4,035. Hmm, I need to calculate this multiplication. First, I remember that multiplying large numbers can be broken down into smaller parts using the standard multiplication method.\\n\\nLet me start by breaking down 4,035 into 4,000 + 35. That might make it easier. So, 34,957 multiplied by 4,000 and then 34,957 multiplied by 35, and then add those two results together.\\n\\nWait, multiplying by 4,000 is the same as multiplying by 4 and then by 1,000. Let me do 34,957 * 4 first. 34,957 times 4: 30,000 * 4 is 120,000. 4,000 * 4 is 16,000. 900 * 4 is 3,600. 50 * 4 is 200. 7 * 4 is 28. Adding those together: 120,000 + 16,000 = 136,000. 136,000 + 3,600 = 139,600. Plus 200 is 139,800. Plus 28 is 139,828. Then I need to multiply that by 1,000 (since 4,000 is 4 * 1,000), so that's 139,828,000.\\n\\nNow, 34,957 * 35. Let's break that down. 35 is 30 + 5. So first, 34,957 * 30. 34,957 * 10 is 349,570, so times 3 is 1,048,710. Then 34,957 * 5 is 174,785. Adding those two together: 1,048,710 + 174,785 = 1,223,495.\\n\\nNow, add the two results: 139,828,000 + 1,223,495 = 141,051,495. Let me double-check these steps to make sure I didn't make a mistake in any of the multiplications or additions.\\n\\nWait, let me verify 34,957 * 4 again. 34,957 * 4: 30,000 * 4 = 120,000. 4,000 * 4 = 16,000. 900 * 4 = 3,600. 50 * 4 = 200. 7 * 4 = 28. Adding all these steps: 120,000 + 16,000 is 136,000. Then 136,000 + 3,600 is 139,600. Then 139,600 + 200 = 139,800. Then 139,800 + 28 = 139,828. So 139,828 * 1,000 is indeed 139,828,000.\\n\\nFor 34,957 * 30: 34,957 * 10 = 349,570. Times 3 is 1,048,710. Then 34,957 * 5: 30,000 *5 = 150,000. 4,000 *5=20,000. 900 *5=4,500. 50 *5=250. 7*5=35. Adding those: 150,000 +20,000=170,000. +4,500=174,500. +250=174,750. +35=174,785. Then 1,048,710 + 174,785 = 1,223,495. Adding that to 139,828,000 gives 141,051,495. Let me check with a different method just to be sure. Maybe using another multiplication strategy, like expanding both numbers.\\n\\nAlternatively, 4,035 is 4.035 × 10³. So 34,957 × 4.035 × 10³. Let's compute 34,957 × 4.035 first. 34,957 × 4 = 139,828. 34,957 × 0.035 = ?\\n\\n0.035 is 0.03 + 0.005. So 34,957 × 0.03 = 1,048.71. 34,957 × 0.005 = 174.785. Adding them gives 1,048.71 + 174.785 = 1,223.495. Then adding to 139,828 gives 139,828 + 1,223.495 = 141,051.495. Then multiply by 1,000 (the 10³ factor) to get 141,051,495. That matches the earlier result. So I think the calculation is correct. Therefore, the product of 34,957 and 4,035 is 141,051,495.\\n</think>\\n\\nThe product of 34,957 multiplied by 4,035 is **141,051,495**. \\n\\n### Step-by-Step Explanation:\\n1. **Breakdown**:  \\n   Use the distributive property:  \\n   $ 34,957 \\\\times 4,035 = 34,957 \\\\times (4,000 + 35) $.\\n\\n2. **Compute $ 34,957 \\\\times 4,000 $**:  \\n   - $ 34,957 \\\\times 4 = 139,828 $.  \\n   - Append three zeros: $ 139,828 \\\\times 1,000 = 139,828,000 $.\\n\\n3. **Compute $ 34,957 \\\\times 35 $**:  \\n   - $ 34,957 \\\\times 30 = 1,048,710 $.  \\n   - $ 34,957 \\\\times 5 = 174,785 $.  \\n   - Add: $ 1,048,710 + 174,785 = 1,223,495 $.\\n\\n4. **Add partial results**:  \\n   $ 139,828,000 + 1,223,495 = 141,051,495 $.\\n\\nThis method ensures accuracy by decomposing the problem into manageable parts.\""
+            ]
+          },
+          "execution_count": 16,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "output"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "kldzxsdcgEkl"
+      },
+      "source": [
+        "## Synthesizer Agent"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "id": "BHGaRr21ge2e"
+      },
+      "outputs": [],
+      "source": [
+        "synthesizerTemplate = \"\"\"\n",
+        "You are the Lead Synthesis Editor, a high-level intelligence responsible for compiling the final, definitive response to the user. Your core objective is to deliver a single, highly coherent, and contextually accurate answer without revealing the underlying system complexity.\n",
+        "\n",
+        "MANDATE & LOGICAL FRAMEWORK:\n",
+        "\n",
+        "Seamless Integration: Generate a continuous, narrative response. The user must never know that multiple sub-agents (RAG, SQL, Web) were used. Do not include labels like \"RAG says\" or \"SQL confirms.\"\n",
+        "\n",
+        "Contextual Hierarchy & Wisdom: When information is available from multiple sources, weigh the evidence and prioritize the most authoritative source for the specific query type:\n",
+        "\n",
+        "Internal Data (RAG, SQL): Use this for proprietary definitions, policy details, employee counts, or specific organizational data. If RAG/SQL directly contradicts General Knowledge (Reasoning), the internal data wins.\n",
+        "\n",
+        "Real-Time Data (Web): Use this for external, up-to-date facts (e.g., market trends, recent events, current stock prices). If Web contradicts a theoretical definition from Reasoning, the Web data wins only if the theory has changed recently.\n",
+        "\n",
+        "General Knowledge (Reasoning): Use this for foundational definitions, historical context, or conceptual explanations (e.g., what is OOPS, how does an algorithm work).\n",
+        "\n",
+        "Contradiction Guardrail: If an agent's output is absurd, irrelevant, or obviously contradictory to the question's focus (e.g., the Web Agent gives a cooking recipe for an SQL query), treat that output as null and completely exclude it from the final answer. Always favor logic and direct relevance.\n",
+        "\n",
+        "Citations: Every claim must be supported by a citation corresponding to the data source. Use parentheses at the end of the sentence or clause: (Source: RAG), (Source: SQL), (Source: Web), or (Source: Model Knowledge).\n",
+        "\n",
+        "SOURCE DATA INPUTS:\n",
+        "\n",
+        "Original Question: {query}\n",
+        "\n",
+        "RAG Context (Internal/Policy Data):\n",
+        "{ragOutput}\n",
+        "\n",
+        "SQL Results (Structured Metrics/Counts):\n",
+        "{sqlOutput}\n",
+        "\n",
+        "Web Search Snippets (Current/External Data):\n",
+        "{webOutput}\n",
+        "\n",
+        "Reasoning Agent Output (Conceptual/Theoretical):\n",
+        "{reasoningOutput}\n",
+        "\n",
+        "FINAL DEFINITIVE RESPONSE:\n",
+        "(Begin your response here, synthesizing information from the sources above into a single, cohesive narrative. Apply the logic and citation rules strictly.)\n",
+        "\"\"\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "HIyspZIwgHQE"
+      },
+      "outputs": [],
+      "source": [
+        "class SynthesizerAgent:\n",
+        "    def __init__(self) -> None:\n",
+        "        promptTemplate = ChatPromptTemplate.from_template(synthesizerTemplate)\n",
+        "        llm = ChatCerebras(\n",
+        "            model = \"gpt-oss-120b\"\n",
+        "        )\n",
+        "        chain =  RunnablePassthrough() | promptTemplate | llm | StrOutputParser()\n",
+        "        self.chain = chain\n",
+        "\n",
+        "    def query(self, query) -> str:\n",
+        "        output = self.chain.invoke(query)\n",
+        "        return output"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {
+        "id": "VzXoLQDtgHMF"
+      },
+      "outputs": [],
+      "source": [
+        "s = SynthesizerAgent()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "_CzP63eSYC5T"
+      },
+      "source": [
+        "## Workflow"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "metadata": {
+        "id": "xxpfQQ4jXz_p"
+      },
+      "outputs": [],
+      "source": [
+        "from langgraph.graph import START, END, StateGraph\n",
+        "from typing import TypedDict\n",
+        "from IPython.display import Image, display\n",
+        "from langchain_core.runnables.graph import CurveStyle, MermaidDrawMethod, NodeStyles"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 24,
+      "metadata": {
+        "id": "bAGHVkiIYMzA"
+      },
+      "outputs": [],
+      "source": [
+        "class AgentState(TypedDict):\n",
+        "    internetResults: str\n",
+        "    reasoningResults: str\n",
+        "    sqlResults: str\n",
+        "    ragResults: str\n",
+        "    query: str\n",
+        "    finalAnswer: str"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "UI6u9O1MYl4l"
+      },
+      "outputs": [],
+      "source": [
+        "class Workflow:\n",
+        "  def __init__(self) -> None:\n",
+        "      self.internetSearchAgentObj = InternetSearchAgent()\n",
+        "      self.reasoningAgentObj = ReasoningAgent()\n",
+        "      self.ragAgentObj = RAGAgent()\n",
+        "      self.sqlAgentObj = PostgreSQLAgent(os.environ.get(\"POSTGRE_CONNECTION_STRING\"))\n",
+        "      self.synthesizerAgentObj = SynthesizerAgent()\n",
+        "\n",
+        "  def _internetSearchAgent(self, state: AgentState) -> dict:\n",
+        "      return {\"internetResults\": self.internetSearchAgentObj.query(query=state.get(\"query\"))}\n",
+        "\n",
+        "  def _reasoningAgent(self, state: AgentState) -> dict:\n",
+        "      return {\"reasoningResults\": self.reasoningAgentObj.query(query=state.get(\"query\"))}\n",
+        "\n",
+        "  def _ragAgent(self, state: AgentState) -> dict:\n",
+        "      return {\"ragResults\": self.ragAgentObj.query(query=state.get(\"query\"))}\n",
+        "\n",
+        "  def _sqlAgent(self, state: AgentState) -> dict:\n",
+        "      return {\"sqlResults\": self.sqlAgentObj.query(query=state.get(\"query\"))}\n",
+        "\n",
+        "  def _synthesizerAgent(self, state: AgentState) -> dict:\n",
+        "      return {\"finalAnswer\": self.synthesizerAgentObj.query({\"query\": state[\"query\"], \"reasoningOutput\": state[\"reasoningResults\"], \"webOutput\": state[\"internetResults\"], \"ragOutput\": state[\"ragResults\"], \"sqlOutput\": state[\"sqlResults\"]})}\n",
+        "\n",
+        "  def createWorkflow(self) -> None:\n",
+        "      graph = StateGraph(AgentState)\n",
+        "      graph.add_node(\"internetSearchAgent\", self._internetSearchAgent, )\n",
+        "      graph.add_node(\"reasoningAgent\", self._reasoningAgent,)\n",
+        "      graph.add_node(\"ragAgent\", self._ragAgent)\n",
+        "      graph.add_node(\"sqlAgent\", self._sqlAgent)\n",
+        "      graph.add_node(\"synthesizerAgent\", self._synthesizerAgent, defer = True)\n",
+        "      graph.add_edge(START, \"internetSearchAgent\")\n",
+        "      graph.add_edge(START, \"reasoningAgent\")\n",
+        "      graph.add_edge(START, \"ragAgent\")\n",
+        "      graph.add_edge(START, \"sqlAgent\")\n",
+        "      graph.add_edge(\"internetSearchAgent\", \"synthesizerAgent\")\n",
+        "      graph.add_edge(\"reasoningAgent\", \"synthesizerAgent\")\n",
+        "      graph.add_edge(\"ragAgent\", \"synthesizerAgent\")\n",
+        "      graph.add_edge(\"sqlAgent\", \"synthesizerAgent\")\n",
+        "      graph.add_edge(\"synthesizerAgent\", END)\n",
+        "      self.graph = graph.compile()\n",
+        "\n",
+        "      display(Image(self.graph.get_graph().draw_mermaid_png()))\n",
+        "\n",
+        "  def run(self, query: str) -> str:\n",
+        "      return self.graph.invoke({\"query\": query})[\"finalAnswer\"]"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 26,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 392
+        },
+        "id": "1Mqc1StMliL4",
+        "outputId": "3fa023e9-731e-4765-8bb0-7b8fb3bb5ace"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<IPython.core.display.Image object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "wo = Workflow()\n",
+        "wo.createWorkflow()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "SlTvKBARlnqp"
+      },
+      "outputs": [],
+      "source": [
+        "response = wo.run(\"According to the provided documents, what is the role of a data structure in software design and how does it relate to the physical form of data?\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "GR6Fy_SUnczt"
+      },
+      "outputs": [],
+      "source": [
+        "print(response)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "huAMIlamoCJ6"
+      },
+      "outputs": [],
+      "source": [
+        "response = wo.run(\"Explain what a Database Management System (DBMS) is, and then find the highest recorded salary for a 'Principal Data Scientist'.\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "D0GYw_VDrSUx"
+      },
+      "outputs": [],
+      "source": [
+        "print(response)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "uN7WRQ0krTmD"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

notebooks/SQLPoplulator.ipynb

@@ -0,0 +1,531 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "lv2nI8oDZBwx",
+        "outputId": "a0783fd9-bab8-4f2d-a35c-2ec12ea39da4"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Requirement already satisfied: sqlalchemy in /usr/local/lib/python3.12/dist-packages (2.0.44)\n",
+            "Requirement already satisfied: psycopg2 in /usr/local/lib/python3.12/dist-packages (2.9.11)\n",
+            "Requirement already satisfied: pandas in /usr/local/lib/python3.12/dist-packages (2.2.2)\n",
+            "Requirement already satisfied: greenlet>=1 in /usr/local/lib/python3.12/dist-packages (from sqlalchemy) (3.2.4)\n",
+            "Requirement already satisfied: typing-extensions>=4.6.0 in /usr/local/lib/python3.12/dist-packages (from sqlalchemy) (4.15.0)\n",
+            "Requirement already satisfied: numpy>=1.26.0 in /usr/local/lib/python3.12/dist-packages (from pandas) (2.0.2)\n",
+            "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.12/dist-packages (from pandas) (2.9.0.post0)\n",
+            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/dist-packages (from pandas) (2025.2)\n",
+            "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/dist-packages (from pandas) (2025.2)\n",
+            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.8.2->pandas) (1.17.0)\n"
+          ]
+        }
+      ],
+      "source": [
+        "!pip install sqlalchemy psycopg2 pandas"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 360
+        },
+        "id": "4jJ55ColUV5d",
+        "outputId": "df044c10-364c-4c77-ea53-f3d257f213db"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "summary": "{\n  \"name\": \"data\",\n  \"rows\": 15000,\n  \"fields\": [\n    {\n      \"column\": \"job_id\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 15000,\n        \"samples\": [\n          \"AI11500\",\n          \"AI06476\",\n          \"AI13168\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"job_title\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 20,\n        \"samples\": [\n          \"AI Research Scientist\",\n          \"Data Scientist\",\n          \"Head of AI\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"salary_usd\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 60260,\n        \"min\": 32519,\n        \"max\": 399095,\n        \"num_unique_values\": 14315,\n        \"samples\": [\n          121638,\n          125960,\n          47012\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"salary_currency\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 3,\n        \"samples\": [\n          \"USD\",\n          \"EUR\",\n          \"GBP\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"experience_level\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 4,\n        \"samples\": [\n          \"EN\",\n          \"EX\",\n          \"SE\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"employment_type\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 4,\n        \"samples\": [\n          \"FL\",\n          \"FT\",\n          \"CT\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"company_location\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 20,\n        \"samples\": [\n          \"China\",\n          \"Denmark\",\n          \"Australia\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"company_size\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 3,\n        \"samples\": [\n          \"M\",\n          \"L\",\n          \"S\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"employee_residence\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 20,\n        \"samples\": [\n          \"China\",\n          \"Japan\",\n          \"Switzerland\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"remote_ratio\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 40,\n        \"min\": 0,\n        \"max\": 100,\n        \"num_unique_values\": 3,\n        \"samples\": [\n          50,\n          100,\n          0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"required_skills\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 13663,\n        \"samples\": [\n          \"Spark, Python, Hadoop\",\n          \"PyTorch, Kubernetes, Computer Vision, Docker\",\n          \"Git, Hadoop, Java, PyTorch\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"education_required\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 4,\n        \"samples\": [\n          \"Master\",\n          \"PhD\",\n          \"Bachelor\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"years_experience\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 5,\n        \"min\": 0,\n        \"max\": 19,\n        \"num_unique_values\": 20,\n        \"samples\": [\n          9,\n          13,\n          19\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"industry\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 15,\n        \"samples\": [\n          \"Energy\",\n          \"Real Estate\",\n          \"Automotive\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"posting_date\",\n      \"properties\": {\n        \"dtype\": \"object\",\n        \"num_unique_values\": 486,\n        \"samples\": [\n          \"2024-12-01\",\n          \"2024-08-15\",\n          \"2024-04-16\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"application_deadline\",\n      \"properties\": {\n        \"dtype\": \"object\",\n        \"num_unique_values\": 543,\n        \"samples\": [\n          \"2025-07-06\",\n          \"2025-07-01\",\n          \"2024-03-18\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"job_description_length\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 576,\n        \"min\": 500,\n        \"max\": 2499,\n        \"num_unique_values\": 2000,\n        \"samples\": [\n          1520,\n          571,\n          1113\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"benefits_score\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 1.4508696496026827,\n        \"min\": 5.0,\n        \"max\": 10.0,\n        \"num_unique_values\": 51,\n        \"samples\": [\n          8.4,\n          9.5,\n          8.3\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"company_name\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 16,\n        \"samples\": [\n          \"Smart Analytics\",\n          \"TechCorp Inc\",\n          \"Neural Networks Co\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}",
+              "type": "dataframe",
+              "variable_name": "data"
+            },
+            "text/html": [
+              "\n",
+              "  <div id=\"df-65321346-6d61-4cd5-b8f0-14ad6f32170a\" class=\"colab-df-container\">\n",
+              "    <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>job_id</th>\n",
+              "      <th>job_title</th>\n",
+              "      <th>salary_usd</th>\n",
+              "      <th>salary_currency</th>\n",
+              "      <th>experience_level</th>\n",
+              "      <th>employment_type</th>\n",
+              "      <th>company_location</th>\n",
+              "      <th>company_size</th>\n",
+              "      <th>employee_residence</th>\n",
+              "      <th>remote_ratio</th>\n",
+              "      <th>required_skills</th>\n",
+              "      <th>education_required</th>\n",
+              "      <th>years_experience</th>\n",
+              "      <th>industry</th>\n",
+              "      <th>posting_date</th>\n",
+              "      <th>application_deadline</th>\n",
+              "      <th>job_description_length</th>\n",
+              "      <th>benefits_score</th>\n",
+              "      <th>company_name</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>AI00001</td>\n",
+              "      <td>AI Research Scientist</td>\n",
+              "      <td>90376</td>\n",
+              "      <td>USD</td>\n",
+              "      <td>SE</td>\n",
+              "      <td>CT</td>\n",
+              "      <td>China</td>\n",
+              "      <td>M</td>\n",
+              "      <td>China</td>\n",
+              "      <td>50</td>\n",
+              "      <td>Tableau, PyTorch, Kubernetes, Linux, NLP</td>\n",
+              "      <td>Bachelor</td>\n",
+              "      <td>9</td>\n",
+              "      <td>Automotive</td>\n",
+              "      <td>2024-10-18</td>\n",
+              "      <td>2024-11-07</td>\n",
+              "      <td>1076</td>\n",
+              "      <td>5.9</td>\n",
+              "      <td>Smart Analytics</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>AI00002</td>\n",
+              "      <td>AI Software Engineer</td>\n",
+              "      <td>61895</td>\n",
+              "      <td>USD</td>\n",
+              "      <td>EN</td>\n",
+              "      <td>CT</td>\n",
+              "      <td>Canada</td>\n",
+              "      <td>M</td>\n",
+              "      <td>Ireland</td>\n",
+              "      <td>100</td>\n",
+              "      <td>Deep Learning, AWS, Mathematics, Python, Docker</td>\n",
+              "      <td>Master</td>\n",
+              "      <td>1</td>\n",
+              "      <td>Media</td>\n",
+              "      <td>2024-11-20</td>\n",
+              "      <td>2025-01-11</td>\n",
+              "      <td>1268</td>\n",
+              "      <td>5.2</td>\n",
+              "      <td>TechCorp Inc</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>AI00003</td>\n",
+              "      <td>AI Specialist</td>\n",
+              "      <td>152626</td>\n",
+              "      <td>USD</td>\n",
+              "      <td>MI</td>\n",
+              "      <td>FL</td>\n",
+              "      <td>Switzerland</td>\n",
+              "      <td>L</td>\n",
+              "      <td>South Korea</td>\n",
+              "      <td>0</td>\n",
+              "      <td>Kubernetes, Deep Learning, Java, Hadoop, NLP</td>\n",
+              "      <td>Associate</td>\n",
+              "      <td>2</td>\n",
+              "      <td>Education</td>\n",
+              "      <td>2025-03-18</td>\n",
+              "      <td>2025-04-07</td>\n",
+              "      <td>1974</td>\n",
+              "      <td>9.4</td>\n",
+              "      <td>Autonomous Tech</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>AI00004</td>\n",
+              "      <td>NLP Engineer</td>\n",
+              "      <td>80215</td>\n",
+              "      <td>USD</td>\n",
+              "      <td>SE</td>\n",
+              "      <td>FL</td>\n",
+              "      <td>India</td>\n",
+              "      <td>M</td>\n",
+              "      <td>India</td>\n",
+              "      <td>50</td>\n",
+              "      <td>Scala, SQL, Linux, Python</td>\n",
+              "      <td>PhD</td>\n",
+              "      <td>7</td>\n",
+              "      <td>Consulting</td>\n",
+              "      <td>2024-12-23</td>\n",
+              "      <td>2025-02-24</td>\n",
+              "      <td>1345</td>\n",
+              "      <td>8.6</td>\n",
+              "      <td>Future Systems</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>AI00005</td>\n",
+              "      <td>AI Consultant</td>\n",
+              "      <td>54624</td>\n",
+              "      <td>EUR</td>\n",
+              "      <td>EN</td>\n",
+              "      <td>PT</td>\n",
+              "      <td>France</td>\n",
+              "      <td>S</td>\n",
+              "      <td>Singapore</td>\n",
+              "      <td>100</td>\n",
+              "      <td>MLOps, Java, Tableau, Python</td>\n",
+              "      <td>Master</td>\n",
+              "      <td>0</td>\n",
+              "      <td>Media</td>\n",
+              "      <td>2025-04-15</td>\n",
+              "      <td>2025-06-23</td>\n",
+              "      <td>1989</td>\n",
+              "      <td>6.6</td>\n",
+              "      <td>Advanced Robotics</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>\n",
+              "    <div class=\"colab-df-buttons\">\n",
+              "\n",
+              "  <div class=\"colab-df-container\">\n",
+              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-65321346-6d61-4cd5-b8f0-14ad6f32170a')\"\n",
+              "            title=\"Convert this dataframe to an interactive table.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "\n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-buttons div {\n",
+              "      margin-bottom: 4px;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "    <script>\n",
+              "      const buttonEl =\n",
+              "        document.querySelector('#df-65321346-6d61-4cd5-b8f0-14ad6f32170a button.colab-df-convert');\n",
+              "      buttonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "      async function convertToInteractive(key) {\n",
+              "        const element = document.querySelector('#df-65321346-6d61-4cd5-b8f0-14ad6f32170a');\n",
+              "        const dataTable =\n",
+              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                    [key], {});\n",
+              "        if (!dataTable) return;\n",
+              "\n",
+              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "          + ' to learn more about interactive tables.';\n",
+              "        element.innerHTML = '';\n",
+              "        dataTable['output_type'] = 'display_data';\n",
+              "        await google.colab.output.renderOutput(dataTable, element);\n",
+              "        const docLink = document.createElement('div');\n",
+              "        docLink.innerHTML = docLinkHtml;\n",
+              "        element.appendChild(docLink);\n",
+              "      }\n",
+              "    </script>\n",
+              "  </div>\n",
+              "\n",
+              "\n",
+              "    <div id=\"df-00c3ed58-78da-47d0-a670-c989824d3602\">\n",
+              "      <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-00c3ed58-78da-47d0-a670-c989824d3602')\"\n",
+              "                title=\"Suggest charts\"\n",
+              "                style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "      </button>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "      --bg-color: #E8F0FE;\n",
+              "      --fill-color: #1967D2;\n",
+              "      --hover-bg-color: #E2EBFA;\n",
+              "      --hover-fill-color: #174EA6;\n",
+              "      --disabled-fill-color: #AAA;\n",
+              "      --disabled-bg-color: #DDD;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "      --bg-color: #3B4455;\n",
+              "      --fill-color: #D2E3FC;\n",
+              "      --hover-bg-color: #434B5C;\n",
+              "      --hover-fill-color: #FFFFFF;\n",
+              "      --disabled-bg-color: #3B4455;\n",
+              "      --disabled-fill-color: #666;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: var(--bg-color);\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: var(--fill-color);\n",
+              "    height: 32px;\n",
+              "    padding: 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: var(--hover-bg-color);\n",
+              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: var(--button-hover-fill-color);\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart-complete:disabled,\n",
+              "  .colab-df-quickchart-complete:disabled:hover {\n",
+              "    background-color: var(--disabled-bg-color);\n",
+              "    fill: var(--disabled-fill-color);\n",
+              "    box-shadow: none;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-spinner {\n",
+              "    border: 2px solid var(--fill-color);\n",
+              "    border-color: transparent;\n",
+              "    border-bottom-color: var(--fill-color);\n",
+              "    animation:\n",
+              "      spin 1s steps(1) infinite;\n",
+              "  }\n",
+              "\n",
+              "  @keyframes spin {\n",
+              "    0% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "      border-left-color: var(--fill-color);\n",
+              "    }\n",
+              "    20% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    30% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    40% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    60% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    80% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "    90% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "      <script>\n",
+              "        async function quickchart(key) {\n",
+              "          const quickchartButtonEl =\n",
+              "            document.querySelector('#' + key + ' button');\n",
+              "          quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+              "          quickchartButtonEl.classList.add('colab-df-spinner');\n",
+              "          try {\n",
+              "            const charts = await google.colab.kernel.invokeFunction(\n",
+              "                'suggestCharts', [key], {});\n",
+              "          } catch (error) {\n",
+              "            console.error('Error during call to suggestCharts:', error);\n",
+              "          }\n",
+              "          quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+              "          quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+              "        }\n",
+              "        (() => {\n",
+              "          let quickchartButtonEl =\n",
+              "            document.querySelector('#df-00c3ed58-78da-47d0-a670-c989824d3602 button');\n",
+              "          quickchartButtonEl.style.display =\n",
+              "            google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "        })();\n",
+              "      </script>\n",
+              "    </div>\n",
+              "\n",
+              "    </div>\n",
+              "  </div>\n"
+            ],
+            "text/plain": [
+              "    job_id              job_title  salary_usd salary_currency  \\\n",
+              "0  AI00001  AI Research Scientist       90376             USD   \n",
+              "1  AI00002   AI Software Engineer       61895             USD   \n",
+              "2  AI00003          AI Specialist      152626             USD   \n",
+              "3  AI00004           NLP Engineer       80215             USD   \n",
+              "4  AI00005          AI Consultant       54624             EUR   \n",
+              "\n",
+              "  experience_level employment_type company_location company_size  \\\n",
+              "0               SE              CT            China            M   \n",
+              "1               EN              CT           Canada            M   \n",
+              "2               MI              FL      Switzerland            L   \n",
+              "3               SE              FL            India            M   \n",
+              "4               EN              PT           France            S   \n",
+              "\n",
+              "  employee_residence  remote_ratio  \\\n",
+              "0              China            50   \n",
+              "1            Ireland           100   \n",
+              "2        South Korea             0   \n",
+              "3              India            50   \n",
+              "4          Singapore           100   \n",
+              "\n",
+              "                                   required_skills education_required  \\\n",
+              "0         Tableau, PyTorch, Kubernetes, Linux, NLP           Bachelor   \n",
+              "1  Deep Learning, AWS, Mathematics, Python, Docker             Master   \n",
+              "2     Kubernetes, Deep Learning, Java, Hadoop, NLP          Associate   \n",
+              "3                        Scala, SQL, Linux, Python                PhD   \n",
+              "4                     MLOps, Java, Tableau, Python             Master   \n",
+              "\n",
+              "   years_experience    industry posting_date application_deadline  \\\n",
+              "0                 9  Automotive   2024-10-18           2024-11-07   \n",
+              "1                 1       Media   2024-11-20           2025-01-11   \n",
+              "2                 2   Education   2025-03-18           2025-04-07   \n",
+              "3                 7  Consulting   2024-12-23           2025-02-24   \n",
+              "4                 0       Media   2025-04-15           2025-06-23   \n",
+              "\n",
+              "   job_description_length  benefits_score       company_name  \n",
+              "0                    1076             5.9    Smart Analytics  \n",
+              "1                    1268             5.2       TechCorp Inc  \n",
+              "2                    1974             9.4    Autonomous Tech  \n",
+              "3                    1345             8.6     Future Systems  \n",
+              "4                    1989             6.6  Advanced Robotics  "
+            ]
+          },
+          "execution_count": 21,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "import pandas as pd\n",
+        "data = pd.read_csv(\"/content/ai_job_dataset.csv\")\n",
+        "data.head()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "EGq5wykmYr37"
+      },
+      "outputs": [],
+      "source": [
+        "from sqlalchemy import create_engine\n",
+        "import os\n",
+        "engine = create_engine(\n",
+        "    os.environ.get(\"POSTGRE_CONNECTION_STRING\")\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "_UpDDKFbYv8q",
+        "outputId": "e3f3f43e-1f77-4a24-b1a8-7db41ae75d76"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "1000"
+            ]
+          },
+          "execution_count": 23,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "data.to_sql(\"sampleTable\", con = engine)"
+      ]
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

prompts.yaml

@@ -0,0 +1,80 @@
+ragTemplate: |
+    You are an expert, fact-checking assistant. Your sole purpose is to answer the user's question.
+
+    CONSTRAINTS:
+    1. **USE ONLY THE PROVIDED CONTEXT**. Do not use any prior knowledge or external information.
+    2. If the context does not contain the answer, you **MUST** respond with: "I do not have enough information to answer the question based on the provided documents." DO NOT make up an answer.
+    3. Your answer must be **complete**, **accurate**, and directly address the user's question.
+    4. For every statement you make, cite the source document. For this exercise, assume the entire context can be from multiple sources, and please state **(Source: <content source from metadata of retrieved documents>)** at the end of the sentence or paragraph, but not the page number.
+
+    CONTEXT:
+    {context}
+
+    ---
+
+    QUESTION: {query}
+
+
+reasoningTemplate: |
+    You are the General Knowledge and Reasoning Agent. Your function is to provide clear, concise, and expert explanations of widely established academic concepts, definitions, and common-sense knowledge. You must rely exclusively on your core training data and internal knowledge.
+
+    MANDATE:
+
+    Answer factual, common knowledge, definition, or theoretical questions.
+
+    CRITICAL REASONING STEP (CoT): For all problem-solving, analytical, or multi-part questions, you MUST perform the following internal steps:
+    a. Analyze: Carefully interpret the overall user problem and its objectives.
+    b. Breakdown: Decompose the problem into sequential, logical sub-parts.
+    c. Solve: Execute the necessary reasoning steps for each sub-part rigorously.
+    d. Synthesize: Combine the results into a single, cohesive, final answer.
+
+    Provide structured, high-quality explanations, examples, and summaries.
+
+    CONSTRAINTS (CRITICAL ANTI-HALLUCINATION RULES):
+
+    DO NOT answer any question that requires accessing external, private, or real-time data. This includes but is not limited to: recent news, local weather, file content (RAG), specific company metrics (SQL), or any data more recent than your last training cutoff.
+
+    IMMEDIATELY and EXCLUSIVELY respond with the exact phrase: "Knowledge gap detected. This query requires external data access (RAG, SQL, or Web)." if the answer is not already in your internal knowledge base.
+
+    Ensure your response is clear, professional, and directly addresses the query.
+
+    QUESTION: {query}
+
+
+synthesizerTemplate: |
+    You are the Lead Synthesis Editor, a high-level intelligence responsible for compiling the final, definitive response to the user. Your core objective is to deliver a single, highly coherent, and contextually accurate answer without revealing the underlying system complexity.
+
+    MANDATE & LOGICAL FRAMEWORK:
+
+    Seamless Integration: Generate a continuous, narrative response. The user must never know that multiple sub-agents (RAG, SQL, Web) were used. Do not include labels like "RAG says" or "SQL confirms."
+
+    Contextual Hierarchy & Wisdom: When information is available from multiple sources, weigh the evidence and prioritize the most authoritative source for the specific query type:
+
+    Internal Data (RAG, SQL): Use this for proprietary definitions, policy details, employee counts, or specific organizational data. If RAG/SQL directly contradicts General Knowledge (Reasoning), the internal data wins.
+
+    Real-Time Data (Web): Use this for external, up-to-date facts (e.g., market trends, recent events, current stock prices). If Web contradicts a theoretical definition from Reasoning, the Web data wins only if the theory has changed recently.
+
+    General Knowledge (Reasoning): Use this for foundational definitions, historical context, or conceptual explanations (e.g., what is OOPS, how does an algorithm work).
+
+    Contradiction Guardrail: If an agent's output is absurd, irrelevant, or obviously contradictory to the question's focus (e.g., the Web Agent gives a cooking recipe for an SQL query), treat that output as null and completely exclude it from the final answer. Always favor logic and direct relevance.
+
+    Citations: Every claim must be supported by a citation corresponding to the data source. Use parentheses at the end of the sentence or clause: (Source: RAG), (Source: SQL), (Source: Web), or (Source: Model Knowledge).
+
+    SOURCE DATA INPUTS:
+
+    Original Question: {query}
+
+    RAG Context (Internal/Policy Data):
+    {ragOutput}
+
+    SQL Results (Structured Metrics/Counts):
+    {sqlOutput}
+
+    Web Search Snippets (Current/External Data):
+    {webOutput}
+
+    Reasoning Agent Output (Conceptual/Theoretical):
+    {reasoningOutput}
+
+    FINAL DEFINITIVE RESPONSE:
+    (Begin your response here, synthesizing information from the sources above into a single, cohesive narrative. Apply the logic and citation rules strictly.)

pyproject.toml

@@ -0,0 +1,109 @@
+[project]
+name = "agenticdatapipeline"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "aiohappyeyeballs==2.6.1",
+    "aiohttp==3.13.2",
+    "aiosignal==1.4.0",
+    "annotated-doc==0.0.4",
+    "annotated-types==0.7.0",
+    "anyio==4.11.0",
+    "attrs==25.4.0",
+    "certifi==2025.11.12",
+    "charset-normalizer==3.4.4",
+    "click==8.3.1",
+    "coloredlogs==15.0.1",
+    "dataclasses-json==0.6.7",
+    "distro==1.9.0",
+    "fastapi==0.121.2",
+    "fastembed==0.7.3",
+    "filelock==3.20.0",
+    "flatbuffers==25.9.23",
+    "frozenlist==1.8.0",
+    "fsspec==2025.10.0",
+    "greenlet==3.2.4",
+    "grpcio==1.76.0",
+    "h11==0.16.0",
+    "h2==4.3.0",
+    "hf-xet==1.2.0",
+    "hpack==4.1.0",
+    "httpcore==1.0.9",
+    "httpx==0.28.1",
+    "httpx-sse==0.4.3",
+    "huggingface-hub==0.36.0",
+    "humanfriendly==10.0",
+    "hyperframe==6.1.0",
+    "idna==3.11",
+    "jinja2==3.1.6",
+    "jiter==0.12.0",
+    "joblib==1.5.2",
+    "jsonpatch==1.33",
+    "jsonpointer==3.0.0",
+    "langchain==1.0.7",
+    "langchain-cerebras==0.7.0",
+    "langchain-classic==1.0.0",
+    "langchain-community==0.4.1",
+    "langchain-core==1.0.5",
+    "langchain-huggingface==1.0.1",
+    "langchain-openai==1.0.3",
+    "langchain-qdrant==1.1.0",
+    "langchain-text-splitters==1.0.0",
+    "langgraph==1.0.3",
+    "langgraph-checkpoint==3.0.1",
+    "langgraph-prebuilt==1.0.4",
+    "langgraph-sdk==0.2.9",
+    "langsmith==0.4.43",
+    "loguru==0.7.3",
+    "markupsafe==3.0.3",
+    "marshmallow==3.26.1",
+    "mmh3==5.2.0",
+    "mpmath==1.3.0",
+    "multidict==6.7.0",
+    "mypy-extensions==1.1.0",
+    "networkx==3.5",
+    "numpy==2.3.5",
+    "onnxruntime==1.23.2",
+    "openai==2.8.1",
+    "orjson==3.11.4",
+    "ormsgpack==1.12.0",
+    "packaging==25.0",
+    "pillow==11.3.0",
+    "portalocker==3.2.0",
+    "propcache==0.4.1",
+    "protobuf==6.33.1",
+    "py-rust-stemmers==0.1.5",
+    "pydantic==2.12.4",
+    "pydantic-core==2.41.5",
+    "pydantic-settings==2.12.0",
+    "python-dotenv==1.2.1",
+    "pyyaml==6.0.3",
+    "qdrant-client==1.16.0",
+    "regex==2025.11.3",
+    "requests==2.32.5",
+    "requests-toolbelt==1.0.0",
+    "safetensors==0.6.2",
+    "scikit-learn==1.7.2",
+    "scipy==1.16.3",
+    "sentence-transformers==5.1.2",
+    "sniffio==1.3.1",
+    "sqlalchemy==2.0.44",
+    "starlette==0.49.3",
+    "sympy==1.14.0",
+    "tenacity==9.1.2",
+    "threadpoolctl==3.6.0",
+    "tiktoken==0.12.0",
+    "tokenizers==0.22.1",
+    "tqdm==4.67.1",
+    "transformers==4.57.1",
+    "typing-extensions==4.15.0",
+    "typing-inspect==0.9.0",
+    "typing-inspection==0.4.2",
+    "urllib3==2.5.0",
+    "uvicorn==0.38.0",
+    "xxhash==3.6.0",
+    "yarl==1.22.0",
+    "zstandard==0.25.0",
+]

src/components/internetSearchAgent.py

@@ -0,0 +1,18 @@
+from langchain_community.utilities import GoogleSerperAPIWrapper
+from utils.exceptions import CustomException
+from utils.logger import logger
+import os
+
+class InternetSearchAgent:
+    def __init__(self) -> None:
+        logger.info("INITIALIZING INTERNET SEARCH AGENT")
+        self.search = GoogleSerperAPIWrapper(serper_api_key=os.environ.get("SERPER_API_KEY"))
+
+    def query(self, query) -> str:
+        try:
+            output = self.search.run(query)
+            return output
+        except Exception as e:
+            exception = CustomException(e)
+            logger.error(exception)
+            raise exception

src/components/ragAgent.py

@@ -0,0 +1,65 @@
+from langchain_qdrant import FastEmbedSparse, RetrievalMode
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_core.prompts import ChatPromptTemplate
+from utils.initMethods import getConfig, readYaml
+from langchain_qdrant import QdrantVectorStore
+from utils.exceptions import CustomException
+from langchain_cerebras import ChatCerebras
+from qdrant_client import QdrantClient
+from utils.logger import logger
+import os
+
+config = getConfig(os.path.join(os.getcwd(), "config.ini"))
+
+modelName = config.get("RAGAGENT", "denseEmbeddings")
+modelKwargs = {'device': 'cpu'}
+encodeKwargs = {'normalize_embeddings': True}
+embeddings = HuggingFaceEmbeddings(
+    model_name=modelName,
+    model_kwargs=modelKwargs,
+    encode_kwargs=encodeKwargs
+)
+
+sparseEmbeddings = FastEmbedSparse(model_name=config.get("RAGAGENT", "sparseEmbeddings"))
+
+class RAGAgent:
+    def __init__(self) -> None:
+        try:
+            logger.info("INITIALIZING RAG AGENT")
+            client = QdrantClient(
+                url=os.environ.get("QDRANT_URL"),
+                api_key=os.environ.get("QDRANT_API_KEY"),
+            )
+            vectorStore = QdrantVectorStore(
+                client=client,
+                collection_name="sampleCollection",
+                embedding=embeddings,
+                vector_name="semantic-search",
+                sparse_vector_name="syntactic-search",
+                retrieval_mode=RetrievalMode.SPARSE,
+                sparse_embedding=sparseEmbeddings
+            )
+            promptTemplate = ChatPromptTemplate.from_template(readYaml(os.path.join(os.getcwd(), "prompts.yaml").get("ragTemplate")))
+            retriever = vectorStore.as_retriever(search_kwargs = {"k": 5})
+            llm = ChatCerebras(
+                model = config.get("RAGAGENT", "modelName"),
+                temperature = config.getint("RAGAGENT", "temperature"),
+                max_tokens = config.getint("RAGAGENT", "maxTokens")
+            )
+            chain = {"query": RunnablePassthrough(), "context": RunnablePassthrough() | retriever} | promptTemplate | llm | StrOutputParser()
+            self.chain = chain
+        except Exception as e:
+            exception = CustomException(e)
+            logger.error(exception)
+            raise exception
+
+    def query(self, query) -> str:
+        try:
+            output = self.chain.invoke(query)
+            return output
+        except Exception as e:
+            exception = CustomException(e)
+            logger.error(exception)
+            raise exception

src/components/reasoningAgent.py

@@ -0,0 +1,36 @@
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
+from langchain_core.prompts import ChatPromptTemplate
+from utils.initMethods import readYaml, getConfig
+from utils.exceptions import CustomException
+from langchain_cerebras import ChatCerebras
+from utils.logger import logger
+import os
+
+config = getConfig(os.path.join(os.getcwd(), "config.ini"))
+prompts = readYaml(os.path.join(os.getcwd(), "prompts.yaml"))
+
+class ReasoningAgent:
+    def __init__(self) -> None:
+        try:
+            logger.info("INITIALIZING REASONING AGENT")
+            promptTemplate = ChatPromptTemplate.from_template(prompts.get("reasoningTemplate"))
+            llm = ChatCerebras(
+                model = config.get("REASONINGAGENT", "modelName"),
+                temperature = config.getint("REASONINGAGENT", "temperature")
+            )
+            chain = {"query": RunnablePassthrough()} | promptTemplate | llm | StrOutputParser()
+            self.chain = chain
+        except Exception as e:
+            exception = CustomException(e)
+            logger.error(exception)
+            raise exception
+
+    def query(self, query) -> str:
+        try:
+            output = self.chain.invoke(query)
+            return output
+        except Exception as e:
+            exception = CustomException(e)
+            logger.error(exception)
+            raise exception

src/components/sqlAgent.py

@@ -0,0 +1,44 @@
+from langchain_community.agent_toolkits.sql.toolkit import SQLDatabaseToolkit
+from langchain_community.utilities.sql_database import SQLDatabase
+from utils.exceptions import CustomException
+from langchain_cerebras import ChatCerebras
+from langchain.agents import create_agent
+from utils.initMethods import getConfig
+from sqlalchemy.pool import StaticPool
+from sqlalchemy import create_engine
+from langchain_classic import hub
+from utils.logger import logger
+import os
+
+promptTemplate = hub.pull("langchain-ai/sql-agent-system-prompt")
+systemMessage = promptTemplate.format(dialect="PostgreSQL", top_k=5)
+
+class PostgreSQLAgent:
+    def __init__(self) -> None:
+        try:
+            logger.info("INITIALIZING SQL AGENT")
+            self.config = getConfig(os.path.join(os.getcwd(), "config.ini"))
+            self.engine = create_engine(os.environ.get("POSTGRE_CONNECTION_STRING"), poolclass = StaticPool)
+            db = SQLDatabase(self.engine)
+            llm = ChatCerebras(
+                model = self.config.get("SQLAGENT", "modelName"),
+                temperature = self.config.getint("SQLAGENT", "temperature"),
+                max_tokens = self.config.getint("SQLAGENT", "maxTokens")
+            )
+            self.toolkit = SQLDatabaseToolkit(db = db, llm = llm)
+            self.agent = create_agent(llm, self.toolkit.get_tools(), system_prompt=systemMessage)
+        except Exception as e:
+            exception = CustomException(e)
+            logger.error(exception)
+            raise exception
+
+    def query(self, query) -> str:
+        try:
+            response = self.agent.invoke(
+                {"messages": [("user", query)]}
+            )
+            return response["messages"][-1].content
+        except Exception as e:
+            exception = CustomException(e)
+            logger.error(exception)
+            raise exception

src/components/synthesizerAgent.py

@@ -0,0 +1,37 @@
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
+from langchain_core.prompts import ChatPromptTemplate
+from utils.initMethods import readYaml, getConfig
+from utils.exceptions import CustomException
+from langchain_cerebras import ChatCerebras
+from utils.logger import logger
+import os
+
+config = getConfig(os.path.join(os.getcwd(), "config.ini"))
+prompts = readYaml(os.path.join(os.getcwd(), "prompts.yaml"))
+
+class SynthesizerAgent:
+    def __init__(self) -> None:
+        try:
+            logger.info("INITIALIZING SYNTHESIZER AGENT")
+            promptTemplate = ChatPromptTemplate.from_template(prompts.get("synthesizerTemplate"))
+            llm = ChatCerebras(
+                model = config.get("SYNTHESIZERAGENT", "modelName"),
+                temperature = config.getint("SYNTHESIZERAGENT", "temperature"),
+                max_tokens = config.getint("SYNTHESIZERAGENT", "maxTokens")
+            )
+            chain = RunnablePassthrough() | promptTemplate | llm | StrOutputParser()
+            self.chain = chain
+        except Exception as e:
+            exception = CustomException(e)
+            logger.error(exception)
+            raise exception
+
+    def query(self, query) -> str:
+        try:
+            output = self.chain.invoke(query)
+            return output
+        except Exception as e:
+            exception = CustomException(e)
+            logger.error(exception)
+            raise exception

src/workflows/workflow.py

@@ -0,0 +1,71 @@
+from src.components.internetSearchAgent import InternetSearchAgent
+from src.components.synthesizerAgent import SynthesizerAgent
+from src.components.reasoningAgent import ReasoningAgent
+from src.components.sqlAgent import PostgreSQLAgent
+from langgraph.graph import START, END, StateGraph
+from utils.exceptions import CustomException
+from src.components.ragAgent import RAGAgent
+from utils.logger import logger
+from typing import TypedDict
+
+class AgentState(TypedDict):
+    internetResults: str
+    reasoningResults: str
+    sqlResults: str
+    ragResults: str
+    query: str
+    finalAnswer: str
+
+class Workflow:
+    def __init__(self) -> None:
+        self.internetSearchAgentObj = InternetSearchAgent()
+        self.reasoningAgentObj = ReasoningAgent()
+        self.ragAgentObj = RAGAgent()
+        self.sqlAgentObj = PostgreSQLAgent()
+        self.synthesizerAgentObj = SynthesizerAgent()
+
+    def _internetSearchAgent(self, state: AgentState) -> dict:
+        return {"internetResults": self.internetSearchAgentObj.query(query=state.get("query"))}
+
+    def _reasoningAgent(self, state: AgentState) -> dict:
+        return {"reasoningResults": self.reasoningAgentObj.query(query=state.get("query"))}
+
+    def _ragAgent(self, state: AgentState) -> dict:
+        return {"ragResults": self.ragAgentObj.query(query=state.get("query"))}
+
+    def _sqlAgent(self, state: AgentState) -> dict:
+        return {"sqlResults": self.sqlAgentObj.query(query=state.get("query"))}
+
+    def _synthesizerAgent(self, state: AgentState) -> dict:
+        return {"finalAnswer": self.synthesizerAgentObj.query({"query": state["query"], "reasoningOutput": state["reasoningResults"], "webOutput": state["internetResults"], "ragOutput": state["ragResults"], "sqlOutput": state["sqlResults"]})}
+
+    def createWorkflow(self) -> None:
+        try:
+            logger.info("INITIALIZING LANGGRAPH WORKFLOW")
+            graph = StateGraph(AgentState)
+            graph.add_node("internetSearchAgent", self._internetSearchAgent, )
+            graph.add_node("reasoningAgent", self._reasoningAgent,)
+            graph.add_node("ragAgent", self._ragAgent)
+            graph.add_node("sqlAgent", self._sqlAgent)
+            graph.add_node("synthesizerAgent", self._synthesizerAgent, defer = True)
+            graph.add_edge(START, "internetSearchAgent")
+            graph.add_edge(START, "reasoningAgent")
+            graph.add_edge(START, "ragAgent")
+            graph.add_edge(START, "sqlAgent")
+            graph.add_edge("internetSearchAgent", "synthesizerAgent")
+            graph.add_edge("reasoningAgent", "synthesizerAgent")
+            graph.add_edge("ragAgent", "synthesizerAgent")
+            graph.add_edge("sqlAgent", "synthesizerAgent")
+            graph.add_edge("synthesizerAgent", END)
+            self.graph = graph.compile()
+            return
+        except Exception as e:
+            exception = CustomException(e)
+            logger.error(exception)
+            raise exception
+
+    def run(self, query: str) -> str:
+        return self.graph.invoke({"query": query})["finalAnswer"]
+    
+workflow = Workflow()
+workflow.createWorkflow()

utils/exceptions.py

@@ -0,0 +1,12 @@
+import traceback
+
+class CustomException(Exception):
+    def __init__(self, exception: Exception) -> None:
+        tb = traceback.extract_tb(tb = exception.__traceback__)[-1]
+        customErrorMessage = "Error encountered in line no [{lineNumber}], filename : [{fileName}], saying [{errorMessage}]"
+        customErrorMessage = customErrorMessage.format(
+            lineNumber = tb.lineno,
+            fileName = tb.filename,
+            errorMessage = str(exception)
+        )
+        super().__init__(customErrorMessage)

utils/initMethods.py

@@ -0,0 +1,12 @@
+import configparser
+import yaml
+
+def readYaml(filePath: str) -> dict:
+    with open(filePath, "r") as f:
+        content = yaml.safe_load(f)
+    return content 
+
+def getConfig(path: str) -> dict:
+    config = configparser.ConfigParser()
+    config.read(path)
+    return config

utils/logger.py

@@ -0,0 +1,18 @@
+from loguru import logger
+import sys
+import os
+
+os.makedirs("logs", exist_ok=True)
+
+logger.remove()
+logger.add(
+    sys.stdout,
+    colorize=True,
+    format="<green>{time}</green> | <level>{level}</level> | <cyan>{message}</cyan>",
+    level="INFO",
+)
+logger.add(
+    "logs/runLogs.log",
+    level="DEBUG",
+    rotation="1 MB",
+)