Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,16 @@ 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
+docs/google.docx filter=lfs diff=lfs merge=lfs -text
+docs/lena.png filter=lfs diff=lfs merge=lfs -text
+docs[[:space:]]copy/google.docx filter=lfs diff=lfs merge=lfs -text
+docs[[:space:]]copy/lena.png filter=lfs diff=lfs merge=lfs -text
+images/attention_mechanism.png filter=lfs diff=lfs merge=lfs -text
+images/common_mistakes.png filter=lfs diff=lfs merge=lfs -text
+images/conclusion.png filter=lfs diff=lfs merge=lfs -text
+images/machine_learning_overview.png filter=lfs diff=lfs merge=lfs -text
+images/ml_common_mistakes.png filter=lfs diff=lfs merge=lfs -text
+images/ml_model_example.png filter=lfs diff=lfs merge=lfs -text
+images/ml_workflow_diagram.png filter=lfs diff=lfs merge=lfs -text
+images/transformer_application.png filter=lfs diff=lfs merge=lfs -text
+images/transformer_architecture.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -205,4 +205,12 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
-images/
+
+
+
+db/
+api/public/
+
+scratch/
+docs/
+

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "python-envs.defaultEnvManager": "ms-python.python:venv",
+    "python-envs.defaultPackageManager": "ms-python.python:pip"
+}

README.md

@@ -1,134 +1,139 @@
-
-
 ---
-title: Multi-Rag AI
-emoji: 🐠
+title: Multi-Rag
+emoji: 🎓
 colorFrom: blue
 colorTo: green
 sdk: docker
-app_file: Dockerfile
-app_port: 7860
+app_file: main.py
 pinned: false
+short_description: This is the Agentic Blog Writing Agent
 ---
 
 
 <div align="center">
-  <h1>🤖 AIAgents Platform</h1>
-  <p><strong>Intelligent AI Agents Powered by LangGraph, LangChain, and FastAPI</strong></p>
+  <h1>🚀 Multi-RAG AI Pipeline</h1>
+  <p><strong>Advanced Multi-Agent RAG Orchestration powered by LangGraph, AWS Bedrock, and FAISS</strong></p>
+
+  [![Python](https://img.shields.io/badge/Python-3.12+-blue.svg)](https://www.python.org/)
+  [![LangGraph](https://img.shields.io/badge/Framework-LangGraph-orange.svg)](https://github.com/langchain-ai/langgraph)
+  [![FastAPI](https://img.shields.io/badge/Backend-FastAPI-green.svg)](https://fastapi.tiangolo.com/)
+  [![FAISS](https://img.shields.io/badge/VectorDB-FAISS-red.svg)](https://github.com/facebookresearch/faiss)
 </div>
 
-<br />
+---
+
+## 📖 Overview
+
+**Multi-RAG AI** is a state-of-the-art, multi-agent RAG (Retrieval-Augmented Generation) pipeline designed for high-performance document intelligence. It leverages **LangGraph** for sophisticated orchestration, allowing an autonomous "Orchestrator" agent to decide which specialized workers (PDF, DOCX, TXT, Images, Web Search) are needed to answer complex user queries.
+
+### Why Multi-RAG?
+- **Intelligent Fan-out**: The orchestrator can trigger multiple workers in parallel to gather information from different sources.
+- **Dynamic Routing**: Automatically detects file types and routes tasks to specialized loaders.
+- **OCR Integration**: Built-in support for image processing and optical character recognition.
+- **Web Search Fallback**: If local documents are insufficient, the agents can autonomously search the live web.
+
+---
+
+## 🏗️ Architecture
+
+The system is built as a nested graph structure, providing a clean separation between high-level orchestration and low-level specialized tasks.
+
+### 1. Main Orchestration Graph
+The main graph handles the interaction between the user, the orchestrator, and the final chat response.
 
-Welcome to **AIAgents**, a full-stack, state-of-the-art framework for building and deploying extremely scalable, multi-agent AI ecosystems! Featuring powerful autonomous agents for complex Web Research, Blog Generation, Document RAG functionality, and interactive multi-turn chatting!
+![Main Graph Architecture](./graph.png)
+
+### 2. Worker Sub-Graph
+The worker sub-graph is responsible for specialized information retrieval from various file formats.
+
+![Worker Sub-Graph](./worker_sub_graph.png)
 
 ---
 
-## 🚀 Features
+## ✨ Key Features
 
-- **✍️ Bloggig (Blog Agent)**: Powerful autonomous agent that researches, writes, and generates high-quality blog posts complete with AI-generated visuals.
-- **🌐 Web Research Agent**: Automatically browse, scrape, and synthesize live internet data straight from any URL (including YouTube videos!) directly within the web interface.
-- **📚 Multi-turn RAG Chat**: Chat with arbitrary text or PDF documents using deep LangGraph memory, powerful sentence transformers for vector retrieval, and advanced orchestration logic.
-- **🎨 Stunning UI**: Beautiful, fully-responsive, custom Dark Mode interface crafted natively with Jinja2 Templating, vanilla HTML/CSS/JS, and glassmorphism UI elements.
-- **⚡ Supercharged Backend**: High-performance asynchronous API crafted using FastAPI.
-- **🛠️ Extensible AI Architecture**: Built on top of the robust **LangChain** and **LangGraph** Python ecosystem to allow autonomous scaling of multi-agent workflows.
+- **📂 Multi-Format Support**:
+  - **PDF**: Deep document parsing.
+  - **DOCX**: Microsoft Word document integration.
+  - **TXT**: Plain text analysis.
+  - **Images (OCR)**: Extraction of text from PNG/JPG using specialized loaders.
+- **🤖 Autonomous Orchestration**: Uses a Llama-3.3-70B model on **AWS Bedrock** with a manual JSON fallback mechanism for 100% reliable structured output.
+- **🔍 Hybrid Retrieval**: Combines local FAISS vector stores with real-time Google Search integration.
+- **🧠 Persistence & Memory**: Full multi-turn conversation support with LangGraph checkpointers.
+- **⚡ Modern Tech Stack**: Built with `uv` for lightning-fast dependency management and `FastAPI` for a high-performance backend.
+
+---
 
 ## 🛠️ Tech Stack
 
-- **Backend**: Python 3.12+, FastAPI, Uvicorn
-- **AI Frameworks**: LangChain, LangGraph, Sentence-Transformers, HuggingFace
-- **LLMs**: AWS Bedrock (Claude 3.5 Sonnet, Claude 3 Haiku, Llama 3), OpenAI (GPT-4o)
-- **Vector Database**: FAISS (Facebook AI Similarity Search)
-- **Frontend**: Jinja2 Templates, Vanilla JS, CSS3, DOM manipulation
-- **Development Tooling**: `uv` (Fast Python Package Manager)
+- **Core**: [Python 3.12](https://www.python.org/)
+- **Orchestration**: [LangGraph](https://github.com/langchain-ai/langgraph) & [LangChain](https://github.com/langchain-ai/langchain)
+- **Large Language Models**: [AWS Bedrock](https://aws.amazon.com/bedrock/) (Llama 3.3 70B)
+- **Vector Storage**: [FAISS](https://github.com/facebookresearch/faiss)
+- **Embeddings**: [HuggingFace](https://huggingface.co/) (all-MiniLM-L6-v2)
+- **Backend API**: [FastAPI](https://fastapi.tiangolo.com/)
+- **Package Management**: [uv](https://github.com/astral-sh/uv)
 
 ---
 
-## ⚙️ Quickstart
+## 🚀 Getting Started
 
 ### Prerequisites
-
-- Ensure you have **Python >= 3.12** installed on your system.
-- Make sure you are using [uv](https://github.com/astral-sh/uv) to manage project dependencies!
+- Python 3.12+
+- `uv` installed (`pip install uv`)
+- AWS Credentials (for Bedrock access)
 
 ### 1. Installation
-
-1. **Clone the repository**:
 ```bash
-git clone https://github.com/VashuTheGreat/AiAgents.git
-cd AiAgents
-```
+# Clone the repository
+git clone https://github.com/VashuTheGreat/Multi-Rag.git
+cd Multi-Rag
 
-2. **Set up the virtual environment & install dependencies** using `uv`:
-```bash
+# Install dependencies
 uv sync
 ```
 
-### 2. Environment Variables
-
-Create a `.env` file in the root of the project and place your necessary API keys inside.
-
+### 2. Environment Setup
+Create a `.env` file in the root directory:
 ```env
-# General
-APP_API_KEY="your_custom_auth_key"
+# AWS Bedrock Config
+AWS_ACCESS_KEY_ID=your_access_key
+AWS_SECRET_ACCESS_KEY=your_secret_key
+AWS_REGION_NAME=us-east-1
 
-# AWS Bedrock (For Blog Agent)
-AWS_ACCESS_KEY_ID="your_key"
-AWS_SECRET_ACCESS_KEY="your_secret"
-AWS_REGION_NAME="us-east-1"
-
-# OpenAI
-OPENAI_API_KEY="sk-..."
+# Tooling (e.g., Search API keys if applicable)
+# ...
 ```
 
-### 3. Run the Server
-
-Simply launch the FastAPI application:
+### 3. Run the Application
 ```bash
-uv run .\main.py
+# Start the FastAPI server
+uv run main.py
 ```
-This will start the development server. Navigate to `http://127.0.0.1:8000/` to see the AIAgents Hub!
-
----
-
-## 🎨 Walkthrough of the Application
-
-### 🏠 Home Page (`/`)
-An elegant gateway into the available AI agent interfaces.
-
-### ✍️ Blog Agent (`/blog`)
-The flagship feature. Enter a topic, and Bloggig will autonomously research the subject, plan its structure, write the content in Markdown, and generate relevant images. It features a real-time "pipeline console" to track the agent's progress.
-
-### 🌐 Web Summarizer (`/web`)
-Paste any URL or YouTube Link to extract and summarize content using our custom LangGraph architecture.
-
-### 💬 Chat MultiGraph (`/chat`)
-Engage with your locally uploaded documents via RAG (Retrieval-Augmented Generation) with intelligent memory buffers.
+Navigate to `http://127.0.0.1:8000` to start chatting with your documents!
 
 ---
 
 ## 📂 Project Structure
 
 ```bash
-AiAgents/
-├─ api/
-│  ├─ Blog/           # Bloggig-specific routers and models
-│  ├─ MultiRag/       # Document RAG routers
-│  └─ Web/            # Web Summarizer routers
-├─ src/
-│  ├─ Blog/           # Bloggig Agent logic (Graph, Nodes, Prompts)
-│  ├─ MultiRag/       # RAG Agent logic (Retrievers, Vectorstores, etc.)
-│  └─ Web/            # Web Agent logic (Loaders, Graph)
-├─ images/            # Generated blog visualizations
-├─ results/           # Saved blog markdown outputs
-├─ static/            # CSS, JS, and local frontend assets
-├─ templates/         # Jinja2 HTML templates
-├─ data/              # Raw document storage for RAG
-├─ db/                # Local FAISS vector database storage
-└─ pyproject.toml     # Project dependencies (uv)
+Multi-Rag/
+├── api/                # FastAPI Endpoints & Controllers
+├── src/
+│   └── MultiRag/
+│       ├── components/ # Core graph runners & embedders
+│       ├── graph/      # LangGraph definitions (Main & Worker)
+│       ├── models/     # Pydantic state & output schemas
+│       ├── nodes/      # Individual graph node implementations
+│       ├── prompts/    # LLM system prompts
+│       └── utils/      # Ingestion & document processing utilities
+├── static/             # Frontend assets (CSS, JS)
+├── templates/          # Jinja2 HTML templates
+└── db/                 # Local FAISS index persistence
 ```
 
 ---
 
 <div align="center">
-  <p>Crafted with ❤️ for professional creators.</p>
+  <p>Built with 💖 for the future of Agentic RAG.</p>
 </div>

api/MultiRag/controllers/loadUserContent_component.py

@@ -0,0 +1,21 @@
+
+from utils.asyncHandler import asyncHandler
+from utils.main_utils import load_yaml
+from api.constants import DATA_FOLDER_PATH,USER_CONTENT_FILE_NAME
+from src.MultiRag.models.rag_model import Content
+
+@asyncHandler
+async def load_user_content(thread_id):
+    user_data = load_yaml(f"{DATA_FOLDER_PATH}/{thread_id}/{USER_CONTENT_FILE_NAME}")
+    user_content = []
+    if user_data:
+        for content in user_data.get("Contents", []):
+            user_content.append(
+                Content(
+                    name=content["name"],
+                    about=content["about"],
+                    path=content["path"]
+                )
+            )
+
+    return user_content

api/MultiRag/routes/analyse_url.py

@@ -0,0 +1,18 @@
+import fastapi
+
+import logging
+
+router = fastapi.APIRouter()
+
+
+@router.post("/analyse_url")
+async def analyse_url(thread_id:str,url: str):
+    try:
+        
+        if not url:
+            return {"data": "URL missing in headers"}
+        res = await run_agent(thread_id, url)
+        return {"data": res}
+    except Exception as e:
+        logging.error(f"Chat endpoint error: {e}")
+        return {"data": "Failed to chat"}

api/MultiRag/routes/chat_route.py

@@ -1,32 +1,31 @@
 from fastapi import APIRouter, Request, Query
 import logging
 import logging
+from src.MultiRag.pipeline.run_pipeline import RunPipeline
 from src.MultiRag.graph.builder import graph
+from src.MultiRag.models.rag_model import Content
+from api.MultiRag.controllers.loadUserContent_component import load_user_content
+from exception import MyException
 
 router = APIRouter()
 
-
-async def run_agent(user_id, userQuery: str):
-    logging.info("Starting AIAgents application...")
-    # Sample initial state for testing
-    config = {"configurable": {"thread_id": user_id}}
-    initial_state = {
-        "userQuery": userQuery,
-        "db_path": f"db/{user_id}",
-        "docs_path": f"data/{user_id}",
-        "k": 3
-    }
+run_pipeline = RunPipeline()
+async def run_agent(user_id, thread_id, userQuery: str):
+    logging.info(f"Starting AIAgents application for thread: {thread_id}")
+     
     try:
-        response = await graph.ainvoke(initial_state, config=config)
-        logging.debug(f"Graph response: {response}")
-        logging.info("Graph invocation successful.")
-        res = response.get("llm_response", "No response found.")
+        temp_user_content = await load_user_content(thread_id)
+       
+
+        res = await run_pipeline.initiate(
+            thread_id=thread_id, 
+            query=userQuery,
+            userContent=temp_user_content
+        )
         return res
     except Exception as e:
         logging.error(f"Application failed: {e}")
-        import traceback
-        logging.error(traceback.format_exc())
-        return "Chat failed due to internal error"
+        raise MyException("AIAgents application failed") from e
     finally:
         logging.info("AIAgents application finished.")
 
@@ -35,10 +34,21 @@ async def run_agent(user_id, userQuery: str):
 async def chat(req: Request, message: str = Query(...)):
     try:
         user_id = req.headers.get("user_id")
+        thread_id = req.headers.get("thread_id") or user_id
         if not user_id:
             return {"data": "User ID missing in headers"}
-        res = await run_agent(user_id, message)
-        return {"data": res}
+        res = await run_agent(user_id, thread_id, message)
+        
+        # Extract the last message content to send to frontend
+        messages = res.get("messages", [])
+        if messages:
+            last_msg = messages[-1]
+            content = last_msg.content if hasattr(last_msg, 'content') else str(last_msg)
+            return {"data": content}
+            
+        return {"data": "No response from agent."}
     except Exception as e:
         logging.error(f"Chat endpoint error: {e}")
         return {"data": "Chat failed"}
+
+          

api/MultiRag/routes/delete_thread_route.py

@@ -0,0 +1,29 @@
+import fastapi
+import logging
+import os
+import shutil
+from exception import MyException
+from api.constants import DATA_FOLDER_PATH,DB_FOLDER_PATH
+from src.MultiRag.graph.builder import deleteThread
+router = fastapi.APIRouter()
+
+
+@router.delete("/delete_thread")
+async def delete_thread(thread_id: str):
+    try:
+        logging.info(f"Attempting to delete thread {thread_id}")
+        await deleteThread(thread_id)
+        
+        data_path = f"{DATA_FOLDER_PATH}/{thread_id}"
+        db_path = f"{DB_FOLDER_PATH}/{thread_id}"
+        
+        if os.path.exists(data_path):
+            shutil.rmtree(data_path)
+        if os.path.exists(db_path):
+            shutil.rmtree(db_path)
+            
+        logging.info(f"Successfully deleted thread {thread_id}")
+        return {"message": f"Thread {thread_id} has been deleted."}
+    except Exception as e:
+        logging.error(f"Failed to delete thread {thread_id}: {str(e)}")
+        raise MyException("Failed to delete thread") from e

api/MultiRag/routes/get_all_thread_route.py

@@ -0,0 +1,16 @@
+from src.MultiRag.graph.builder import retrieve_all_threads
+import fastapi
+import logging
+
+router = fastapi.APIRouter()
+
+@router.get("/get_all_thread")
+async def get_all_thread():
+    try:
+        logging.info("Received request to get all threads")
+        threads = await retrieve_all_threads()
+        logging.info(f"Retrieved all threads successfully {threads}")
+        return {"threads": threads}
+    except Exception as e:
+        logging.error(f"Error retrieving threads: {e}")
+        return {"message": "Failed to retrieve threads"}

api/MultiRag/routes/get_available_file_fomates_route.py

@@ -0,0 +1,10 @@
+
+
+import fastapi
+from api.constants import AVAILABLE_ANALYSIS
+router = fastapi.APIRouter()
+
+
+@router.get("/")
+async def get_available_file_fomates():
+    return {"message": "Available file formats: pdf, txt, docx, image","data":AVAILABLE_ANALYSIS}

api/MultiRag/routes/load_conversation_route.py

@@ -0,0 +1,17 @@
+import fastapi
+from src.MultiRag.graph.builder import load_conversation
+import logging
+
+router = fastapi.APIRouter()
+
+@router.get("/load_conversation")
+async def get_conversation(thread_id: str):
+    try:
+        logging.info(f"Loading conversation for thread_id: {thread_id}")
+        messages = await load_conversation(thread_id)
+        logging.info(f"Conversation loaded successfully for thread_id: {thread_id}")
+        return {"messages": messages}
+    except Exception as e:
+        logging.error(f"Error loading conversation for thread_id: {thread_id}: {e}")
+        return {"message": "Failed to load conversation"}
+    

api/MultiRag/routes/pages_route.py

@@ -8,24 +8,24 @@ templates = Jinja2Templates(directory="templates")
 
 _APP_USER_ID = os.getenv("APP_API_KEY", "")
 
-@router.get("/")
-async def read_root(request: Request):
-    return templates.TemplateResponse(
-        name="home.html",
-        context={"request": request, "app_user_id": _APP_USER_ID}
-    )
+# @router.get("/")
+# async def read_root(request: Request):
+#     return templates.TemplateResponse(
+#         name="home.html",
+#         context={"request": request, "app_user_id": _APP_USER_ID}
+#     )
 
 
-@router.get("/chat")
+@router.get("/")
 async def chat_model(request: Request):
     return templates.TemplateResponse(
         name="chat.html",
         context={"request": request, "app_user_id": _APP_USER_ID}
     )
 
-@router.get("/web")
-async def web_page(request: Request):
-    return templates.TemplateResponse(
-        name="web.html",
-        context={"request": request, "app_user_id": _APP_USER_ID}
-    )
+# @router.get("/web")
+# async def web_page(request: Request):
+#     return templates.TemplateResponse(
+#         name="web.html",
+#         context={"request": request, "app_user_id": _APP_USER_ID}
+#     )

api/MultiRag/routes/uploader_route.py

@@ -1,73 +1,123 @@
 import fastapi
 from fastapi import UploadFile, Request, BackgroundTasks
 import os
-import shutil
-import asyncio
 import logging
-from src.MultiRag.constants import CONTENT_PERSISTENT_TIME, DATA_FOLDER_PATH, DB_FOLDER_PATH
 from src.MultiRag.graph.builder import deleteThread
 from utils.asyncHandler import asyncHandler
-from src.MultiRag.nodes.retreiver_check_node import clear_cached_retriever
-router = fastapi.APIRouter()
-
-
-@asyncHandler
-async def delete_folder_after_time(user_id):
+from utils.main_utils import write_yaml, load_yaml
+from src.MultiRag.models.rag_model import Content
+from src.MultiRag.components.content_embedder import ContentEmbedder
+from src.MultiRag.entity.config_entity import ContentEmbedderConfig
+from api.constants import DATA_FOLDER_PATH, USER_CONTENT_FILE_NAME
+from src.MultiRag.graph.builder import graph
+from langchain_core.messages import HumanMessage
 
-    await asyncio.sleep(CONTENT_PERSISTENT_TIME)
-
-    folder_path = f"{DATA_FOLDER_PATH}/{user_id}"
-    db_path = f"{DB_FOLDER_PATH}/{user_id}"
+router = fastapi.APIRouter()
 
-    # Step 1: null refs, gc.collect(), clear_system_cache() — in that order
-    clear_cached_retriever(db_path)
-    await deleteThread(user_id)
+async def generate_retreivers(thread_id: str):
+    yaml_path = f"{DATA_FOLDER_PATH}/{thread_id}/{USER_CONTENT_FILE_NAME}"
+    yaml_content = load_yaml(yaml_path)
+    
+    if not yaml_content or 'Contents' not in yaml_content:
+        logging.warning(f"No contents found in {yaml_path}")
+        return
+
+    for content_dict in yaml_content['Contents']:
+        name = content_dict.get("name")
+        path = content_dict.get("path")
+        
+        logging.info(f"Processing content: {name}")
+    
+        content_embedder_config = ContentEmbedderConfig(
+            file_path=path,
+            vector_store_path=f"db/{thread_id}/{name}",
+        )
+        component = ContentEmbedder(content_embedder_config=content_embedder_config)
+        retreiver = await component.embed_content()
+        logging.info(f"Generated retreiver for {name}: {retreiver}")
+
+@router.post("/")
+async def post_content(
+    req: Request,
+    file: UploadFile
+):
+    try:
+        user_id = req.headers.get("user_id")
+        thread_id = req.headers.get("thread_id") or user_id
+        if not user_id:
+            return {"message": "User ID missing in headers"}
 
-    # Step 2: give Windows 3s to fully release OS-level file locks after GC
-    await asyncio.sleep(3)
+        folder = f"{DATA_FOLDER_PATH}/{thread_id}"
+        os.makedirs(folder, exist_ok=True)
 
-    if os.path.exists(folder_path):
-        shutil.rmtree(folder_path)
-        logging.info(f"Folder deleted: {folder_path}")
+        saved_file_path = f"{folder}/{file.filename}"
+        with open(saved_file_path, "wb") as f:
+            f.write(await file.read())
 
-    if os.path.exists(db_path):
-        for attempt in range(6):
-            try:
-                shutil.rmtree(db_path)
-                logging.info(f"DB deleted: {db_path}")
-                return
-            except PermissionError as e:
-                logging.warning(f"DB delete attempt {attempt+1} failed: {e}")
-                await asyncio.sleep(3)
+        yaml_path = f"{folder}/{USER_CONTENT_FILE_NAME}"
+        
+        content_entry = {
+            "name": file.filename,
+            "about": file.filename,
+            "path": saved_file_path
+        }
 
-        logging.error(f"Failed to delete DB after all retries: {db_path}")
+        # Append to YAML
+        write_yaml(yaml_path, {"Contents": [content_entry]}, mode="a")
+        
+        logging.info(f"File uploaded and entry added to YAML: {file.filename}")
 
+        # Trigger retriever generation
+        await generate_retreivers(thread_id)
 
+        # Notify the AI about the upload in the thread history
+        config = {"configurable": {"thread_id": thread_id}}
+        notification = HumanMessage(content=f"[SYSTEM NOTIFICATION]: User has uploaded a new file: {file.filename}. Please keep this in mind for future queries.")
+        await graph.aupdate_state(config, {"messages": [notification]})
 
-    
+        return {"message": "File uploaded successfully"}
 
+    except Exception as e:
+        logging.error(f"File upload failed: {e}")
+        return {"message": f"File upload failed: {str(e)}"}
 
-@router.post("/post_content")
-async def post_content(
-    req: Request,
-    file: UploadFile,
-    background_tasks: BackgroundTasks
-):
+@router.post("/upload_url")
+async def upload_url(req: Request, url: str):
     try:
         user_id = req.headers.get("user_id")
+        thread_id = req.headers.get("thread_id") or user_id
+        if not user_id:
+            return {"message": "User ID missing in headers"}
 
-        folder = f"{DATA_FOLDER_PATH}/{user_id}"
+        folder = f"{DATA_FOLDER_PATH}/{thread_id}"
         os.makedirs(folder, exist_ok=True)
 
-        file_path = f"{folder}/{file.filename}"
+        yaml_path = f"{folder}/{USER_CONTENT_FILE_NAME}"
+        
+        # Use a truncated URL for the name
+        display_name = (url[:50] + '...') if len(url) > 50 else url
+        
+        content_entry = {
+            "name": display_name,
+            "about": url,
+            "path": url
+        }
 
-        with open(file_path, "wb") as f:
-            f.write(await file.read())
+        # Append to YAML
+        write_yaml(yaml_path, {"Contents": [content_entry]}, mode="a")
+        
+        logging.info(f"URL entry added to YAML: {url}")
 
-        # start background delete timer
-        background_tasks.add_task(delete_folder_after_time, user_id)
+        # Trigger retriever generation (if the embedder supports URLs)
+        await generate_retreivers(thread_id)
 
-        return {"message": "File uploaded successfully"}
+        # Notify the AI about the URL upload
+        config = {"configurable": {"thread_id": thread_id}}
+        notification = HumanMessage(content=f"[SYSTEM NOTIFICATION]: User has uploaded a new URL: {url}. Please keep this in mind for future queries.")
+        await graph.aupdate_state(config, {"messages": [notification]})
+
+        return {"message": "URL uploaded successfully"}
 
     except Exception as e:
-        return {"message": "File upload failed"}
+        logging.error(f"URL upload failed: {e}")
+        return {"message": f"URL upload failed: {str(e)}"}

api/constants/__init__.py

@@ -0,0 +1,8 @@
+DATA_FOLDER_PATH="api/public"
+CONTENT_PERSISTENT_TIME=5
+DB_FOLDER_PATH="db"
+
+AVAILABLE_ANALYSIS=['pdf','txt','docs','docx','png','url']
+
+USER_CONTENT_FILE_NAME="USER_CONTENT.yml"
+

api/main.py

@@ -1,9 +1,6 @@
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
-from api.MultiRag.routes import chat_route, uploader_route, pages_route
-from api.Web.routes import web_talk_routes
-from api.Blog.routes import page_route_blog,blog_router
-from api.Web.routes import page_route_web
+from api.MultiRag.routes import chat_route, uploader_route, pages_route,get_all_thread_route,load_conversation_route,get_available_file_fomates_route, delete_thread_route
 app = FastAPI()
 
 @app.middleware("http")
@@ -34,22 +31,25 @@ async def check_user_id(request: Request, call_next):
     return response
 
 app.include_router(pages_route.router)
-app.include_router(prefix="/chat", router=chat_route.router)
-app.include_router(prefix="/uploader", router=uploader_route.router)
+app.include_router(prefix="/api/v1/chat", router=chat_route.router)
+app.include_router(prefix="/api/v1/uploader", router=uploader_route.router)
+app.include_router(prefix="/api/v1/thread", router=get_all_thread_route.router)
+app.include_router(prefix="/api/v1/thread", router=delete_thread_route.router)
+app.include_router(prefix="/api/v1/conversation", router=load_conversation_route.router)
+app.include_router(prefix="/api/v1/file_formats", router=get_available_file_fomates_route.router)
 
 
 
 
+# # -------------------- Web -------------------------------
+# app.include_router(page_route_web.router)
+# app.include_router(prefix="/web",router=web_talk_routes.router)
 
-# -------------------- Web -------------------------------
-app.include_router(page_route_web.router)
-app.include_router(prefix="/web",router=web_talk_routes.router)
 
 
 
 
-
-# ------------ Blog --------------------
-app.include_router(page_route_blog.router)
-app.include_router(prefix="/blog",router=blog_router.router)
+# # ------------ Blog --------------------
+# app.include_router(page_route_blog.router)
+# app.include_router(prefix="/blog",router=blog_router.router)
 

docs copy/google.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7eee211e7bc83917dde195f15c5458d6877dce8ba9fe080479c26a58e8da4c6a
+size 3020407

docs copy/growing_ai_tools.txt

@@ -0,0 +1 @@
+THE LATEST GROWING AI MODELS (2024-2025)LARGE LANGUAGE MODELS (LLMs) & MULTIMODALGemini 1.5 Pro (Google): Known for its massive context window (up to 2 million tokens), allowing it to process entire libraries or long videos in one go.GPT-4o (OpenAI): An "omni" model designed for seamless real-time interaction across text, audio, and vision.Claude 3.5 Sonnet (Anthropic): Widely praised for its human-like reasoning, coding abilities, and "Artifacts" UI feature.Llama 3.1 (Meta): The leading open-source model series, providing high performance for developers to build private AI applications.DeepSeek-V3: An emerging powerhouse from China gaining traction for its efficiency and strong performance in logic and coding.VIDEO GENERATION MODELS (THE NEW FRONTIER)Sora (OpenAI): A world-simulating model that creates highly realistic 60-second videos.Veo (Google): Google's latest high-definition video generation model with cinematic control.Kling / Luma Dream Machine: Rapidly growing tools accessible to the public for generating high-quality AI video from text prompts.Runway Gen-3 Alpha: A professional-grade video model used by filmmakers and creators for precise motion control.IMAGE & CREATIVE MODELSMidjourney v6: Continues to lead in artistic quality and photorealism.Flux.1 (Black Forest Labs): A new open-weights model that has quickly become a favorite for its incredible detail and ability to render text inside images.DALL-E 3: Integrated into ChatGPT and Bing, focused on strict adherence to complex user prompts.SPECIALIZED & RESEARCH MODELSAlphaFold 3 (Google DeepMind): A revolutionary model for biology that predicts the structure and interactions of all life’s molecules.Grok-2 (xAI): Elon Musk’s AI model integrated into X (Twitter), designed for real-time information access and "edgy" personality.Trends to Watch:Small Language Models (SLMs): Models like Phi-3 or Gemma designed to run locally on phones and laptops.Agentic AI: Models designed not just to talk, but to use tools and complete multi-step tasks autonomously.

docs/google.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7eee211e7bc83917dde195f15c5458d6877dce8ba9fe080479c26a58e8da4c6a
+size 3020407

docs/growing_ai_tools.txt

@@ -0,0 +1 @@
+THE LATEST GROWING AI MODELS (2024-2025)LARGE LANGUAGE MODELS (LLMs) & MULTIMODALGemini 1.5 Pro (Google): Known for its massive context window (up to 2 million tokens), allowing it to process entire libraries or long videos in one go.GPT-4o (OpenAI): An "omni" model designed for seamless real-time interaction across text, audio, and vision.Claude 3.5 Sonnet (Anthropic): Widely praised for its human-like reasoning, coding abilities, and "Artifacts" UI feature.Llama 3.1 (Meta): The leading open-source model series, providing high performance for developers to build private AI applications.DeepSeek-V3: An emerging powerhouse from China gaining traction for its efficiency and strong performance in logic and coding.VIDEO GENERATION MODELS (THE NEW FRONTIER)Sora (OpenAI): A world-simulating model that creates highly realistic 60-second videos.Veo (Google): Google's latest high-definition video generation model with cinematic control.Kling / Luma Dream Machine: Rapidly growing tools accessible to the public for generating high-quality AI video from text prompts.Runway Gen-3 Alpha: A professional-grade video model used by filmmakers and creators for precise motion control.IMAGE & CREATIVE MODELSMidjourney v6: Continues to lead in artistic quality and photorealism.Flux.1 (Black Forest Labs): A new open-weights model that has quickly become a favorite for its incredible detail and ability to render text inside images.DALL-E 3: Integrated into ChatGPT and Bing, focused on strict adherence to complex user prompts.SPECIALIZED & RESEARCH MODELSAlphaFold 3 (Google DeepMind): A revolutionary model for biology that predicts the structure and interactions of all life’s molecules.Grok-2 (xAI): Elon Musk’s AI model integrated into X (Twitter), designed for real-time information access and "edgy" personality.Trends to Watch:Small Language Models (SLMs): Models like Phi-3 or Gemma designed to run locally on phones and laptops.Agentic AI: Models designed not just to talk, but to use tools and complete multi-step tasks autonomously.

exception/__init__.py

@@ -1,35 +1,15 @@
 import sys
 import logging
 
-def error_message_detail(error:Exception,error_detail:sys)->str:
-    _, _, exc_tb = error_detail.exc_info()
 
-    # Walk the traceback to find the actual source of the error
-    while exc_tb.tb_next is not None:
-        exc_tb = exc_tb.tb_next
-
-    # Get the file name where the exception occurred
-    file_name = exc_tb.tb_frame.f_code.co_filename
-
-    # Create a formatted error message string with file name, line number, and the actual error
-    line_number = exc_tb.tb_lineno
-    error_message = f"Error occurred in python script: [{file_name}] at line number [{line_number}]: {str(error)}"
-    
-    # Log the error for better tracking
-    logging.error(error_message)
-    
-    return error_message
 
 class MyException(Exception):
-    def __init__(self, error_message: str, error_detail: sys):
-        # Call the base class constructor with the error message
+    def __init__(self, error_message: str, error_detail: sys = None):
         super().__init__(error_message)
 
-        # Format the detailed error message using the error_message_detail function
-        self.error_message = error_message_detail(error_message, error_detail)
-
+        logging.exception(error_message)
     def __str__(self) -> str:
         """
         Returns the string representation of the error message.
         """
-        return self.error_message
+        return self.args[0]

main.py

@@ -20,6 +20,6 @@ if __name__ == "__main__":
         "main:app",
         host="0.0.0.0",
         port=7860,
-        reload=False,
+        reload=True,
         reload_excludes=["db/*", "data/*", "logs/*", "vector_db/*", ".venv/*"],
     )

pyproject.toml

@@ -6,7 +6,9 @@ readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
     "bert-extractive-summarizer>=0.10.1",
+    "docx2txt>=0.9",
     "dotenv>=0.9.9",
+    "easyocr>=1.7.2",
     "faiss-cpu>=1.13.2",
     "fastapi>=0.135.1",
     "keybert>=0.9.0",
@@ -16,13 +18,21 @@ dependencies = [
     "langchain-community>=0.4.1",
     "langchain-core>=1.2.17",
     "langchain-google-genai>=4.2.1",
+    "langchain-groq>=1.1.2",
     "langchain-huggingface>=1.2.1",
     "langchain-ollama>=1.0.1",
+    "langchain-tavily>=0.2.18",
     "langgraph>=1.0.10",
+    "pdf2image>=1.17.0",
+    "pdfminer-six>=20260107",
+    "pi-heif>=1.3.0",
     "pillow>=12.1.1",
+    "pytesseract>=0.3.13",
     "python-multipart>=0.0.22",
     "sentence-transformers>=5.2.3",
     "transformers>=5.3.0",
     "unstructured>=0.21.5",
+    "unstructured-inference>=1.6.11",
+    "unstructured-pytesseract>=0.3.15",
     "youtube-transcript-api>=1.2.4",
 ]

src/MultiRag/components/content_embedder.py

@@ -0,0 +1,58 @@
+
+from utils.asyncHandler import asyncHandler
+from src.MultiRag.entity.config_entity import ContentEmbedderConfig
+from src.MultiRag.utils.ingestion_utils import create_vector_store,create_retreiver
+from src.MultiRag.constants import RETREIVER_DEFAULT_K
+from src.MultiRag.entity.artifact_entity import RetrievalArtifact
+from abc import ABC, abstractmethod
+import logging
+
+
+class Retreiver(ABC):
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    async def retreive(self, query: str):
+        pass
+
+class ContentRetreiver(Retreiver):
+    def __init__(self, retriever):
+        self.retriever = retriever
+
+    async def retreive(self, query: str):
+        return await self.retriever.ainvoke(query)
+class ContentEmbedder:
+    def __init__(self, content_embedder_config: ContentEmbedderConfig):
+        self.content_embedder_config = content_embedder_config
+
+
+    @asyncHandler
+    async def embed_PDF(self):
+        vector_store = await create_vector_store(path=self.content_embedder_config.vector_store_path, docs=self.content_embedder_config.file_path)
+        return vector_store
+
+    @asyncHandler
+    async def create_retriever(self,vector_store, k:int = RETREIVER_DEFAULT_K)->RetrievalArtifact:
+        retriever = await create_retreiver(vectorstore=vector_store, k=k)
+        return retriever
+    
+
+
+
+    @asyncHandler
+    async def embed_content(self)->RetrievalArtifact:
+        logging.info("Starting content embedding process...")
+
+        vector_store = await self.embed_PDF()
+        if vector_store is None:
+            logging.warning("No vector store created. Returning empty artifact.")
+            return RetrievalArtifact(retreivar=None)
+
+        logging.info("PDF embedding completed. Creating retriever...")
+        retriever = await self.create_retriever(vector_store=vector_store)
+
+        content_retriever = ContentRetreiver(retriever=retriever)
+        logging.info("Retriever created successfully.")
+        return RetrievalArtifact(retreivar=content_retriever)
+        

src/MultiRag/components/run_graph.py

@@ -0,0 +1,20 @@
+from src.MultiRag.graph.builder import graph
+from utils.asyncHandler import asyncHandler
+from src.MultiRag.models.rag_model import State
+
+import logging
+
+class RunComponent:
+    def __init__(self):
+        pass
+    
+
+    @asyncHandler
+    async def run(self,state:State, thread_id:str):
+        logging.info("Entered in the run_component")
+        logging.info(f"Running graph with thread_id: {thread_id}")
+
+        config = {"configurable": {"thread_id": thread_id}}
+        res=await graph.ainvoke(state, config)
+        logging.info(f"Graph execution completed")
+        return res

src/MultiRag/constants/__init__.py

@@ -9,7 +9,7 @@ RETREIVER_DEFAULT_K=3
 LOGS_DIR="logs"
 LLM_MODEL_ID = "us.meta.llama3-3-70b-instruct-v1:0"
 LLM_REGION = "us-east-1"
-
+MODEL_NAME="llama-3.3-70b-versatile"
 
 TOP_K_KEYWORDS=10
 
@@ -19,3 +19,18 @@ DB_FOLDER_PATH="db"
 
 
 
+AVAILABLE_ANALYSIS=['pdf','txt','docs','docx','png','url', 'search']
+
+
+
+# ====================== DB =======================
+DB_FOLDER_PATH="db"
+
+
+
+# ====================== Tool ======================
+SEARCH_MAX_RESULT=5
+SEARCH_TOPIC='general'
+
+
+

src/MultiRag/entity/artifact_entity.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class RetrievalArtifact:
+    retreivar: object

src/MultiRag/entity/config_entity.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+
+@dataclass
+class ContentEmbedderConfig:
+    file_path: str
+    vector_store_path: str
+    file_types: str = "pdf"

src/MultiRag/graph/builder.py

@@ -1,43 +1,136 @@
 import logging
 from langgraph.graph import START, END, StateGraph
 from src.MultiRag.models.rag_model import State
-from src.MultiRag.nodes.retreiver_check_node import retreiver_check
-from src.MultiRag.nodes.queries_generator import query_generator
-from src.MultiRag.nodes.chat_node import chat
-from src.MultiRag.nodes.content_summerizer import content_summerizer
+from src.MultiRag.nodes.chat_node import chat_node
+from src.MultiRag.graph.worker.builder import graph as worker_sub_graph
+from src.MultiRag.nodes.orchestrator_node import orchestrator_node
+from src.MultiRag.nodes.reducer_node import reducer_node
+from langgraph.prebuilt import ToolNode
 from src.MultiRag.memory import memory
-logging.info("Building state graph...")
+from langgraph.types import Send
+from src.MultiRag.tools.web_search import WebSearch
+from langchain.agents.middleware import ToolCallLimitMiddleware
+
+
+
+tool_limiter = ToolCallLimitMiddleware(
+    run_limit=3,   
+    exit_behavior="continue",
+)
+
+def enforce_tool_limit(state: State):
+    updates = tool_limiter.after_model(state, runtime=None)
+    return updates or {}
+
+
+def after_tool_limit(state: State):
+    if state.get("jump_to") == "end":
+        return "chat_node"
+
+    last_message = state.get("messages", [])[-1]
+    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
+        return "tools"
+
+    return "chat_node"
+logging.info("Initializing StateGraph with State model...")
 graph_builder = StateGraph(State)
 
-# Add nodes
-graph_builder.add_node("retreiver_check", retreiver_check)
-graph_builder.add_node("content_summerizer", content_summerizer)
-graph_builder.add_node("qureis_builder", query_generator)
-graph_builder.add_node("chat", chat)
+def fanout(state: State):
+    logging.info("Evaluating fanout condition from orchestrator_node")
+    
+    plan = state.get("plan")
+    if not plan:
+        logging.warning("No plan found in state, defaulting to chat_node")
+        return "chat_node"
+    
+    if not plan.use_worker:
+        logging.info("Orchestrator decided to bypass workers and go to chat")
+        return "chat_node"
+
+    tasks = plan.tasks or []
+    if not tasks:
+        logging.info("No tasks to execute, going to chat_node")
+        return "chat_node"
+
+    logging.info(f"Fanning out {len(tasks)} tasks to workers")
+    
+    return [
+        Send(
+            "worker",
+            {
+                "plan_to_retrieve": task.instruction,
+                "file_type": task.file_type,
+                "file_path": task.file_path,
+                "thread_id": state.get("thread_id", "1"),
+                "worker_result": [],
+            },
+        )
+        for task in tasks
+    ]
+
+
+def should_continue(state: State):
+    last_message=state.get("messages", [])[-1] if state.get("messages") else None
+    if last_message.tool_calls:
+        return "tool_limit"
+    return END
+logging.info("Adding nodes to graph builder: orchestrator_node, chat_node, worker, reducer_node")
+graph_builder.add_node("orchestrator_node", orchestrator_node)
+graph_builder.add_node("chat_node", chat_node)
+graph_builder.add_node("worker", worker_sub_graph)
+graph_builder.add_node("reducer_node", reducer_node)
+graph_builder.add_node("tools", ToolNode([WebSearch().search]))
+graph_builder.add_node("tool_limit", enforce_tool_limit)
+
+logging.info("Configuring graph edges and flow...")
+graph_builder.add_edge(START, "orchestrator_node")
 
-# Add edges
-graph_builder.add_edge(START, "retreiver_check")
-graph_builder.add_edge("retreiver_check", "content_summerizer")
-graph_builder.add_edge("content_summerizer", "qureis_builder")
-graph_builder.add_edge("qureis_builder", "chat")
-graph_builder.add_edge("chat", END)
+logging.info("Setting up conditional edges from orchestrator_node using fanout")
+graph_builder.add_conditional_edges(
+    "orchestrator_node", 
+    fanout, 
+    {
+        "worker": "worker",
+        "chat_node": "chat_node"
+    }
+)
+
+logging.info("Connecting worker to reducer_node and then to chat_node")
+graph_builder.add_edge("worker", "reducer_node")
+graph_builder.add_edge("reducer_node", "chat_node")
+graph_builder.add_conditional_edges(
+    "chat_node",
+    should_continue,
+    ["tool_limit", END]
+)
+# graph_builder.add_conditional_edges("chat_node", should_continue, ["tools", END])
+graph_builder.add_conditional_edges(
+    "tool_limit",
+    after_tool_limit,
+    ["tools", "chat_node"]
+)
+graph_builder.add_edge("tools", "chat_node")
 
 logging.info("Compiling graph...")
 graph = graph_builder.compile(checkpointer=memory)
 
-png_data = graph.get_graph().draw_mermaid_png()
-with open("graph.png", "wb") as f:
-    f.write(png_data)
+try:
+    png_data = graph.get_graph(xray=1).draw_mermaid_png()
+    with open("graph.png", "wb") as f:
+        f.write(png_data)
+    logging.info("Graph visualization saved to graph.png")
+except Exception as e:
+    logging.warning(f"Could not generate graph visualization: {e}")
+
 logging.info("Graph compiled successfully.")
 
 
 
 
-## ----------- Delete Conversion -----------------
+
 async def deleteThread(thread_id: str):
     try:
         cp = memory
-        # Check if thread exists first
         state = await cp.aget_tuple(config={'configurable': {'thread_id': thread_id}})
         if state is None:
             logging.info(f"Thread {thread_id} not found, nothing to delete.")
@@ -49,3 +142,26 @@ async def deleteThread(thread_id: str):
     except Exception as e:
         logging.error(f"Error deleting thread {thread_id}: {e}")
         return False
+
+
+
+async def retrieve_all_threads():
+    try:
+        cp=memory
+        all_threads = set()
+        for checkpoint in cp.list(None):
+            all_threads.add(checkpoint.config["configurable"]["thread_id"])
+        return list(all_threads)
+    except Exception as e:
+        logging.error(f"Error retrieving threads: {e}")
+        return []
+
+
+
+async def load_conversation(thread_id):
+    try:
+        state = graph.get_state(config={'configurable': {'thread_id': thread_id}})
+        return state.values.get('messages', [])
+    except Exception as e:
+        logging.error(f"Error loading conversation: {e}")
+        return []

src/MultiRag/graph/worker/builder.py

@@ -0,0 +1,62 @@
+from langgraph.graph import StateGraph, START, END
+from src.MultiRag.models.worker_model import State
+from src.MultiRag.nodes.worker import (
+    pdf,
+    txt,
+    docs,
+    image,
+    url,
+    decider,
+    search
+)
+from src.MultiRag.constants import AVAILABLE_ANALYSIS
+import logging
+
+logging.info("Building worker sub graph")
+
+graph = StateGraph(State)
+
+graph.add_node("decider", decider.decider_node)
+graph.add_node("pdf", pdf.pdf_node)
+graph.add_node("txt", txt.txt_node)
+graph.add_node("docs", docs.docs_node)
+graph.add_node("url", url.url_node)
+graph.add_node("image", image.image_node)
+graph.add_node("search", search.search_node)
+
+def route_fn(state: State):
+    logging.info(f"Routing based on file_type: {state.file_type}")
+    if state.file_type in AVAILABLE_ANALYSIS:
+        return state.file_type
+    return "end"
+
+graph.add_conditional_edges(
+    START,
+    route_fn,
+    {
+        "pdf": "pdf",
+        "txt": "txt",
+        "docs": "docs",
+        "png": "image",
+        "url": "url",
+        "search": "search",
+        "end":END
+    }
+)
+
+graph.add_edge("pdf", END)
+graph.add_edge("txt", END)
+graph.add_edge("docs", END)
+graph.add_edge("url", END)
+graph.add_edge("image", END)
+graph.add_edge("search", END)
+
+graph = graph.compile()
+
+try:
+    with open("worker_sub_graph.png", "wb") as f:
+        f.write(graph.get_graph().draw_mermaid_png())
+    logging.info("Graph image saved successfully")
+except Exception as e:
+    logging.error(f"Error saving graph: {e}")
+    raise Exception(e)

src/MultiRag/llm/llm_loader.py

@@ -1,9 +1,14 @@
 from langchain_aws import ChatBedrockConverse
-
-from src.MultiRag.constants import LLM_MODEL_ID,LLM_REGION
+from langchain_groq import ChatGroq
+from src.MultiRag.constants import LLM_MODEL_ID,LLM_REGION,MODEL_NAME
 import logging
 llm = ChatBedrockConverse(
     model_id=LLM_MODEL_ID,
     region_name=LLM_REGION
 )
-logging.info(f"LLM initialized with model_id={LLM_MODEL_ID}, region_name={LLM_REGION}")
+
+# llm=ChatGroq(
+#     model=MODEL_NAME
+# )
+# logging.info(f"LLM initialized with model_id={LLM_MODEL_ID}, region_name={LLM_REGION}")
+logging.info(f"LLM initialized with model_name:{MODEL_NAME}")