Upload 5 files

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy backend files
+COPY backend/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY backend/ .
+
+# Expose port
+EXPOSE 7860
+
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,57 @@
 ---
-title: Deep Research Ai
-emoji: 🌖
-colorFrom: pink
-colorTo: blue
+title: Deep Research AI
+emoji: 🔬
+colorFrom: blue
+colorTo: purple
 sdk: docker
 pinned: false
 license: mit
-short_description: Multi-agent AI assistant powered by LangGraph & Gemini
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Deep Research AI 🚀
+
+A sophisticated multi-agent research assistant powered by LangGraph and Google Gemini.
+
+## Features
+
+- 🔬 **Deep Research**: Multi-step research with web search & document analysis
+- 🎥 **YouTube Analyzer**: Generate viral titles & extract captions from videos
+- 📝 **Smart Summarizer**: Auto-summarize long reports with one click
+- 📄 **Document RAG**: Upload PDFs & texts for enhanced knowledge base
+
+## Tech Stack
+
+- **Backend**: FastAPI + LangGraph
+- **AI Models**: Google Gemini 2.0 Flash
+- **Vector Store**: ChromaDB
+- **Web Search**: Tavily API
+
+## Environment Variables
+
+This Space requires the following secrets:
+
+```
+GOOGLE_API_KEY=your_gemini_api_key
+TAVILY_API_KEY=your_tavily_api_key
+```
+
+## API Endpoints
+
+- `POST /api/chat` - Main chat interface
+- `POST /api/summarize` - Content summarization
+- `POST /api/upload` - Document upload
+- `GET /api/health` - Health check
+
+## Frontend
+
+The frontend is deployed separately on Vercel for optimal performance.
+
+Visit: [Your Frontend URL]
+
+## Local Development
+
+```bash
+cd backend
+pip install -r requirements.txt
+uvicorn main:app --reload
+```

agent.py

@@ -0,0 +1,300 @@
+from typing import TypedDict, List, Annotated, Dict, Any
+import operator
+import os
+from dotenv import load_dotenv
+import re
+import json
+
+load_dotenv("../.env", override=True)
+
+from langchain_google_genai import ChatGoogleGenerativeAI, GoogleGenerativeAIEmbeddings
+from langgraph.graph import StateGraph, END
+from langchain_core.messages import HumanMessage, AIMessage, BaseMessage
+from langchain_chroma import Chroma
+from tavily import TavilyClient
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
+from youtube_transcript_api import YouTubeTranscriptApi
+import yt_dlp
+
+# --- Configuration ---
+llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0)
+
+# Initialize Embeddings & Vector Store
+embeddings = GoogleGenerativeAIEmbeddings(model="models/text-embedding-004")
+vector_store = Chroma(embedding_function=embeddings, persist_directory="./chroma_db")
+retriever = vector_store.as_retriever(search_kwargs={"k": 3})
+
+# --- State Definition ---
+class AgentState(TypedDict):
+    """The state of our Deep Research Agent."""
+    task: str
+    plan: List[str]
+    content: Annotated[List[str], operator.add]
+    revision_number: int
+    max_revisions: int
+    final_report: str
+    steps: Annotated[List[str], operator.add]
+    messages: Annotated[List[BaseMessage], operator.add]
+    youtube_url: str
+    youtube_captions: str
+
+# --- Data Models ---
+class Plan(BaseModel):
+    """Plan to follow for research."""
+    steps: List[str] = Field(description="List of research steps/questions to investigate.")
+
+# --- Helpers ---
+def extract_video_id(url):
+    """Extracts the video ID from a YouTube URL."""
+    # Support various URL formats
+    regex = r"(?:v=|\/)([0-9A-Za-z_-]{11}).*"
+    match = re.search(regex, url)
+    if match:
+        return match.group(1)
+    return None
+
+def get_video_duration(url):
+    """Gets video duration in seconds using yt-dlp."""
+    ydl_opts = {'quiet': True}
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info(url, download=False)
+        return info.get('duration', 0)
+
+# --- Nodes ---
+
+def router_node(state: AgentState):
+    """
+    Routes to YouTube processor if a URL is detected, otherwise to Planner.
+    """
+    task = state["task"]
+    if "youtube.com" in task or "youtu.be" in task:
+        # Extract URL from task
+        url_match = re.search(r"(https?://[^\s]+)", task)
+        if url_match:
+            return {"youtube_url": url_match.group(1), "steps": ["Detected YouTube URL, routing to Video Processor"]}
+    return {"steps": ["Routing to Research Planner"]}
+
+def youtube_node(state: AgentState):
+    """
+    Process YouTube video: Check duration, get captions, generate title.
+    """
+    print("---YOUTUBE PROCESSOR---")
+    url = state["youtube_url"]
+    task = state["task"]
+    
+    video_id = extract_video_id(url)
+    if not video_id:
+        return {"final_report": "Error: Could not extract Video ID.", "steps": ["Failed to extract Video ID"]}
+    
+    # Check Duration
+    try:
+        duration = get_video_duration(url)
+        if duration > 600: # 10 minutes
+            return {"final_report": f"Error: Video is too long ({duration//60} mins). Limit is 10 minutes.", "steps": ["Video rejected: Too long"]}
+    except Exception as e:
+        return {"final_report": f"Error checking duration: {e}", "steps": ["Failed to check duration"]}
+        
+    # Get Captions
+    try:
+        print(f"DEBUG: Fetching captions for {video_id}")
+        yt = YouTubeTranscriptApi()
+        transcript_list = yt.list(video_id)
+        # Try to find English, or fallback to first available
+        try:
+            transcript = transcript_list.find_transcript(['en'])
+        except:
+            # Fallback to the first available transcript
+            transcript = next(iter(transcript_list))
+            
+        transcript_data = transcript.fetch()
+        # Handle if it returns objects or dicts (it seems to be objects in this version)
+        transcript_text = " ".join([t.text for t in transcript_data])
+    except Exception as e:
+        print(f"DEBUG: Caption Error: {e}")
+        return {"final_report": f"Error fetching captions: {e}", "steps": ["Failed to fetch captions"]}
+    
+    # Generate Title
+    system = """You are a YouTube Expert. Analyze the provided video transcript and generate 3 catchy, AI-enhanced title options.
+    
+    Provide ONLY the 3 titles in this exact format:
+    VIRAL: [title here]
+    SEO: [title here]  
+    PROFESSIONAL: [title here]
+    
+    Do not add any other text, headers, or explanations. Just the 3 titles."""
+    
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", system),
+            ("human", "Transcript: {transcript}\n\nUser Request: {task}"),
+        ]
+    )
+    
+    chain = prompt | llm | StrOutputParser()
+    raw_titles = chain.invoke({"transcript": transcript_text[:5000], "task": task})
+    
+    # Manually construct a beautifully formatted report with MAXIMUM SPACING
+    report = "# YouTube Video Analysis\n\n\n"
+    report += "---\n\n\n"
+    report += "## 🎬 AI Enhanced Title Options\n\n\n"
+    
+    # Parse the titles and format them nicely with extra spacing
+    lines = raw_titles.strip().split('\n')
+    for line in lines:
+        if line.strip():
+            if ':' in line:
+                category, title = line.split(':', 1)
+                report += f"### {category.strip().title()}\n\n"
+                report += f"**{title.strip()}**\n\n\n"
+    
+    # Check if user wants captions
+    if "caption" in task.lower() or "transcript" in task.lower():
+        report += "---\n\n\n"
+        report += "## 📝 Full Captions\n\n\n"
+        report += f"```text\n{transcript_text}\n```\n\n\n"
+    else:
+        report += "---\n\n\n"
+        report += "> **Note:** Captions are available for this video! Add 'with captions' to your request to see them.\n\n\n"
+        
+    return {
+        "final_report": report, 
+        "youtube_captions": transcript_text,
+        "steps": ["Processed YouTube video: Checked duration, fetched captions, generated title"]
+    }
+
+def plan_node(state: AgentState):
+    """
+    Planner Agent: Breaks down the task into sub-questions.
+    """
+    print("---PLANNER---")
+    task = state["task"]
+    
+    system = """You are a Research Planner. Given a user topic, break it down into 3-5 distinct, specific research questions or sub-topics that need to be investigated to write a comprehensive report.
+    Return the result as a list of strings."""
+    
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", system),
+            ("human", "{task}"),
+        ]
+    )
+    
+    planner = prompt | llm.with_structured_output(Plan)
+    plan = planner.invoke({"task": task})
+    
+    return {
+        "plan": plan.steps, 
+        "steps": [f"Created research plan with {len(plan.steps)} steps: {', '.join(plan.steps)}"]
+    }
+
+def research_node(state: AgentState):
+    """
+    Researcher Agent: Executes the plan.
+    """
+    print("---RESEARCHER---")
+    plan = state["plan"]
+    content = []
+    steps_log = []
+    
+    api_key = os.getenv("TAVILY_API_KEY")
+    tavily = TavilyClient(api_key=api_key) if api_key else None
+
+    for step in plan:
+        print(f"Researching: {step}")
+        steps_log.append(f"Researching: {step}")
+        
+        # 1. Try Vector Store first
+        docs = retriever.invoke(step)
+        if docs:
+            context = "\n".join([d.page_content for d in docs])
+            content.append(f"Source: Local Documents\nTopic: {step}\nContent: {context}")
+        
+        # 2. Always Web Search for "Deep" research to get fresh info
+        if tavily:
+            try:
+                response = tavily.search(query=step, max_results=2)
+                web_docs = response.get('results', [])
+                web_context = "\n".join([d["content"] for d in web_docs])
+                content.append(f"Source: Web Search\nTopic: {step}\nContent: {web_context}")
+            except Exception as e:
+                print(f"Web search error: {e}")
+    
+    return {"content": content, "steps": steps_log}
+
+def writer_node(state: AgentState):
+    """
+    Writer Agent: Synthesizes the report.
+    """
+    print("---WRITER---")
+    task = state["task"]
+    content = state["content"]
+    
+    system = """You are a Professional Research Writer. Your goal is to write a comprehensive, well-structured Markdown report based on the provided research notes.
+    
+    Guidelines:
+    1. **Structure**: Start with an engaging Title (#) and Introduction.
+    2. **Headers**: Use headers (##, ###) to organize sections. **IMPORTANT**: Always add a blank line before and after every header.
+    3. **Content**: Synthesize the information. Do not just list facts.
+    4. **Formatting**:
+       - Use **bold** for key terms.
+       - Use bullet points for lists (ensure there is a blank line before the list starts).
+       - Use > Blockquotes for important summaries.
+    5. **Citations**: If the notes mention specific sources, cite them.
+    6. **Conclusion**: End with a strong conclusion.
+    
+    Make the report visually appealing and easy to read.
+    """
+    
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", system),
+            ("human", "Task: {task}\n\nResearch Notes:\n{content}"),
+        ]
+    )
+    
+    chain = prompt | llm | StrOutputParser()
+    report = chain.invoke({"task": task, "content": "\n\n".join(content)})
+    
+    return {
+        "final_report": report, 
+        "messages": [AIMessage(content=report)], # For compatibility with main.py
+        "steps": ["Wrote final report"]
+    }
+
+def route_task(state: AgentState):
+    """
+    Conditional edge to route to YouTube or Planner.
+    """
+    if state.get("youtube_url"):
+        return "youtube_node"
+    return "planner"
+
+# --- Graph Construction ---
+
+workflow = StateGraph(AgentState)
+
+workflow.add_node("router", router_node)
+workflow.add_node("youtube_node", youtube_node)
+workflow.add_node("planner", plan_node)
+workflow.add_node("researcher", research_node)
+workflow.add_node("writer", writer_node)
+
+workflow.set_entry_point("router")
+
+workflow.add_conditional_edges(
+    "router",
+    route_task,
+    {
+        "youtube_node": "youtube_node",
+        "planner": "planner"
+    }
+)
+
+workflow.add_edge("youtube_node", END)
+workflow.add_edge("planner", "researcher")
+workflow.add_edge("researcher", "writer")
+workflow.add_edge("writer", END)
+
+app = workflow.compile()

main.py

@@ -0,0 +1,161 @@
+from fastapi import FastAPI, HTTPException, UploadFile, File
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Dict, Any
+import os
+import shutil
+from dotenv import load_dotenv
+
+load_dotenv("../.env", override=True) # Load from root
+
+from agent import app as agent_app, vector_store
+from langchain_core.messages import HumanMessage, AIMessage
+from langchain_community.document_loaders import PyPDFLoader, TextLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+app = FastAPI()
+
+@app.on_event("startup")
+async def startup_event():
+    tavily_key = os.getenv("TAVILY_API_KEY")
+    if tavily_key:
+        print(f"Startup: TAVILY_API_KEY found: {tavily_key[:5]}...")
+    else:
+        print("Startup: TAVILY_API_KEY NOT found!")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class ChatRequest(BaseModel):
+    message: str
+    history: List[Dict[str, str]] = []
+
+@app.post("/api/upload")
+async def upload_file(file: UploadFile = File(...)):
+    try:
+        # Save file temporarily
+        file_path = f"temp_{file.filename}"
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+        
+        # Load and split document
+        if file.filename.endswith(".pdf"):
+            loader = PyPDFLoader(file_path)
+        else:
+            loader = TextLoader(file_path)
+            
+        docs = loader.load()
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+        splits = text_splitter.split_documents(docs)
+        
+        # Add to Vector Store
+        vector_store.add_documents(splits)
+        
+        # Cleanup
+        os.remove(file_path)
+        
+        return {"status": "success", "message": f"Processed {len(splits)} chunks"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/chat")
+async def chat_endpoint(request: ChatRequest):
+    try:
+        # Convert history to LangChain messages
+        messages = []
+        for msg in request.history:
+            if msg["role"] == "user":
+                messages.append(HumanMessage(content=msg["content"]))
+            elif msg["role"] == "assistant":
+                messages.append(AIMessage(content=msg["content"]))
+        
+        # Add current message
+        messages.append(HumanMessage(content=request.message))
+        
+        # Invoke Agent
+        # Deep Research Graph expects 'task'
+        inputs = {
+            "task": request.message,
+            "plan": [],
+            "content": [],
+            "revision_number": 0,
+            "max_revisions": 1,
+            "final_report": "",
+            "steps": [],
+            "messages": messages # Keep for history if needed
+        }
+        
+        result = agent_app.invoke(inputs)
+        
+        # Get final report
+        final_response = result.get("final_report", "No report generated.")
+        
+        # Extract steps
+        steps = result.get("steps", [])
+        thoughts = []
+        for step in steps:
+            thoughts.append({
+                "tool": "agent_step",
+                "input": step,
+                "status": "completed"
+            })
+        
+        return {"response": final_response, "thoughts": thoughts}
+    except Exception as e:
+        print(f"Error in chat endpoint: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+class SummarizeRequest(BaseModel):
+    content: str
+
+@app.post("/api/summarize")
+async def summarize_endpoint(request: SummarizeRequest):
+    try:
+        from langchain_google_genai import ChatGoogleGenerativeAI
+        from langchain_core.prompts import ChatPromptTemplate
+        from langchain_core.output_parsers import StrOutputParser
+        
+        llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0)
+        
+        system = """You are a professional summarizer. Create a concise summary of the provided content.
+        
+        Guidelines:
+        1. Keep it to 3-5 sentences
+        2. Capture the main points and key takeaways
+        3. Use clear, simple language
+        4. Maintain the professional tone
+        """
+        
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", system),
+            ("human", "Summarize this content:\n\n{content}")
+        ])
+        
+        chain = prompt | llm | StrOutputParser()
+        summary = chain.invoke({"content": request.content})
+        
+        return {"summary": summary}
+    except Exception as e:
+        print(f"Error in summarize endpoint: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/health")
+async def health_check():
+    return {"status": "ok"}
+
+@app.get("/")
+async def root():
+    return {"message": "RAG Backend is running"}
+
+# Serve static files (Frontend) - to be configured after build
+# app.mount("/", StaticFiles(directory="../frontend/out", html=True), name="static")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,16 @@
+fastapi
+uvicorn
+langgraph
+langchain-google-genai>=1.0.3
+google-generativeai
+tavily-python
+chromadb
+langchain
+langchain-chroma
+langchain-community
+langchain-text-splitters
+pypdf
+python-multipart
+python-dotenv
+youtube-transcript-api
+yt-dlp