added summarizer mode

backend/app/api/routes_chat.py

@@ -1,8 +1,9 @@
-"""Chat routes for Graph-RAG."""
+"""Chat routes for QA and summarization."""
 
 from app.core.llm import llm_chat
-from app.core.prompts import build_rag_prompt
+from app.core.prompts import build_rag_prompt, build_summary_prompt
 from app.models.api import ChatRequest, ChatResponse
+from app.retrieval.chunk_registry import get_chunks
 from app.retrieval.citation_filter import filter_citations
 from app.retrieval.retrieve import hybrid_graph_search
 from fastapi import APIRouter
@@ -12,7 +13,28 @@ router = APIRouter()
 
 @router.post("/ask", response_model=ChatResponse)
 def chat(request: ChatRequest) -> ChatResponse:
-    """Graph-augmented RAG endpoint."""
+    """Unified QA + Summarization endpoint."""
+    if request.mode == "summarize":
+        # Summarization uses ALL chunks (no top_k truncation)
+        chunks = get_chunks()
+
+        if not chunks:
+            return ChatResponse(
+                answer="No documents available to summarize.",
+                citations=[],
+            )
+
+        context = "\n\n".join(chunk.text for chunk in chunks)
+        messages = build_summary_prompt(context)
+
+        answer = llm_chat(messages=messages)
+
+        # no citations for summarization
+        citations = []
+
+        return ChatResponse(answer=answer, citations=citations)
+
+    # QA MODE (default)
     results = hybrid_graph_search(request.query, request.top_k)
 
     if not results:
@@ -22,20 +44,9 @@ def chat(request: ChatRequest) -> ChatResponse:
         )
 
     context = "\n\n".join(sc.chunk.text for sc in results)
-
-    messages = build_rag_prompt(
-        context=context,
-        question=request.query,
-    )
+    messages = build_rag_prompt(context, request.query)
 
     answer = llm_chat(messages=messages)
+    citations = filter_citations(answer=answer, chunks=results)
 
-    citations = filter_citations(
-        answer=answer,
-        chunks=results,
-    )
-
-    return ChatResponse(
-        answer=answer,
-        citations=citations,
-    )
+    return ChatResponse(answer=answer, citations=citations)

backend/app/api/routes_chat_langchain.py

@@ -0,0 +1,53 @@
+"""Chat routes using LangChain retriever."""
+
+from app.config import settings
+from app.models.api import ChatRequest, ChatResponse
+from app.models.retrieval import ScoredChunk
+from app.retrieval.citation_filter import filter_citations
+from app.retrieval.langchain_retriever import AtlasGraphRetriever
+from fastapi import APIRouter
+from langchain.chains import RetrievalQA
+from langchain_groq import ChatGroq
+
+router = APIRouter()
+
+
+@router.post("/ask/langchain", response_model=ChatResponse)
+def chat_langchain(request: ChatRequest) -> ChatResponse:
+    """LangChain-powered RAG endpoint with citation filtering."""
+    retriever = AtlasGraphRetriever(top_k=request.top_k)
+
+    llm = ChatGroq(
+        api_key=settings.groq_api_key,
+        model=settings.default_model,
+    )
+
+    qa_chain = RetrievalQA.from_chain_type(
+        llm=llm,
+        retriever=retriever,
+        return_source_documents=True,
+    )
+
+    result = qa_chain.invoke({"query": request.query})
+
+    answer = result["result"]
+    source_docs = result.get("source_documents", [])
+
+    # Convert LangChain docs → ScoredChunk
+    scored_chunks = [
+        ScoredChunk(
+            chunk=doc.metadata["chunk"],
+            score=doc.metadata["score"],
+        )
+        for doc in source_docs
+    ]
+
+    citations = filter_citations(
+        answer=answer,
+        chunks=scored_chunks,
+    )
+
+    return ChatResponse(
+        answer=answer,
+        citations=citations,
+    )

backend/app/api/routes_summarize.py

@@ -1,33 +0,0 @@
-"""Document summarization route (LangChain-based)."""
-
-from app.models.api import ChatResponse
-from app.retrieval.chunk_registry import get_chunks
-from app.summarization.langchain_summarizer import DocumentSummarizer
-from fastapi import APIRouter, HTTPException
-
-router = APIRouter()
-summarizer = DocumentSummarizer()
-
-
-@router.post("/langchain", response_model=ChatResponse)
-def summarize_document() -> ChatResponse:
-    """Summarize all ingested documents.
-
-    Note:
-    - This is recall-heavy by design
-    - No citations (summary ≠ factual QA)
-    """
-    chunks = get_chunks()
-
-    if not chunks:
-        raise HTTPException(
-            status_code=400,
-            detail="No documents available for summarization.",
-        )
-
-    summary = summarizer.summarize(chunks)
-
-    return ChatResponse(
-        answer=summary,
-        citations=[],
-    )

backend/app/core/prompts.py

@@ -10,6 +10,16 @@ Rules:
 - Do NOT add external knowledge.
 """
 
+SUMMARY_SYSTEM_PROMPT = """
+You are a document summarization assistant.
+
+Rules:
+- Produce a concise, well-structured summary of the provided content.
+- Capture key ideas, steps, and distinctions.
+- Do NOT invent information.
+- Do NOT include instructions, questions, or meta commentary.
+"""
+
 
 def build_rag_prompt(context: str, question: str) -> list[dict]:
     """Build messages for RAG-based QA."""
@@ -26,3 +36,14 @@ Question:
 """.strip(),
         },
     ]
+
+
+def build_summary_prompt(context: str) -> list[dict]:
+    """Build messages for RAG-based summarization."""
+    return [
+        {"role": "system", "content": SUMMARY_SYSTEM_PROMPT},
+        {
+            "role": "user",
+            "content": f"Document Content:\n{context}",
+        },
+    ]

backend/app/main.py

@@ -1,8 +1,8 @@
 """Main FastAPI application for AtlasRAG backend."""
 
 from app.api.routes_chat import router as chat_router
+from app.api.routes_chat_langchain import router as chat_langchain_router
 from app.api.routes_docs import router as docs_router
-from app.api.routes_summarize import router as summarize_langchain_router
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
@@ -24,4 +24,4 @@ app.add_middleware(
 # Include routers
 app.include_router(chat_router, prefix="/chat")
 app.include_router(docs_router, prefix="/docs")
-app.include_router(summarize_langchain_router, prefix="/summarize")
+app.include_router(chat_langchain_router, prefix="/chat")

backend/app/models/api.py

@@ -1,5 +1,7 @@
 """Pydantic models for API request and response bodies."""
 
+from typing import Literal
+
 from pydantic import BaseModel
 
 
@@ -8,6 +10,7 @@ class ChatRequest(BaseModel):
 
     query: str
     top_k: int = 5
+    mode: Literal["qa", "summarize"] = "qa"
 
 
 class Citation(BaseModel):

backend/app/retrieval/langchain_retriever.py

@@ -0,0 +1,35 @@
+"""LangChain retriever wrapper for AtlasRAG."""
+
+from typing import List
+
+from app.retrieval.retrieve import hybrid_graph_search
+from langchain_core.documents import Document
+from langchain_core.retrievers import BaseRetriever
+
+
+class AtlasGraphRetriever(BaseRetriever):
+    """LangChain-compatible retriever wrapping hybrid Graph-RAG."""
+
+    top_k: int = 5
+
+    def _get_relevant_documents(self, query: str) -> List[Document]:
+        """Retrieve documents for LangChain."""
+        results = hybrid_graph_search(query, self.top_k)
+
+        documents: List[Document] = []
+
+        for sc in results:
+            documents.append(
+                Document(
+                    page_content=sc.chunk.text,
+                    metadata={
+                        "doc_id": sc.chunk.doc_id,
+                        "page_start": sc.chunk.page_start,
+                        "page_end": sc.chunk.page_end,
+                        "chunk": sc.chunk,
+                        "score": sc.score,
+                    },
+                )
+            )
+
+        return documents

backend/app/summarization/langchain_summarizer.py

@@ -1,48 +0,0 @@
-"""LangChain-based document summarization using a local HF model."""
-
-from typing import List
-
-from app.models.ingestion import Chunk
-from langchain.chains.summarize import load_summarize_chain
-from langchain.docstore.document import Document
-from langchain.llms import HuggingFacePipeline
-from transformers import pipeline
-
-
-class DocumentSummarizer:
-    """Document summarizer using LangChain + local HF model."""
-
-    def __init__(self) -> None:
-        """Initialize HF Pipeline."""
-        summarizer = pipeline(
-            "summarization",
-            model="facebook/bart-large-cnn",
-            device=-1,
-        )
-
-        self.llm = HuggingFacePipeline(pipeline=summarizer)
-
-        self.chain = load_summarize_chain(
-            llm=self.llm,
-            chain_type="map_reduce",
-            verbose=False,
-        )
-
-    def summarize(self, chunks: List[Chunk]) -> str:
-        """Summarize document chunks."""
-        if not chunks:
-            return "No content available to summarize."
-
-        documents = [
-            Document(
-                page_content=chunk.text,
-                metadata={
-                    "doc_id": chunk.doc_id,
-                    "page_start": chunk.page_start,
-                    "page_end": chunk.page_end,
-                },
-            )
-            for chunk in chunks
-        ]
-
-        return self.chain.run(documents)

requirements.txt

@@ -9,9 +9,12 @@ httpx==0.27.0
 # LLM & Embedding Clients
 openai==1.37.0
 groq==0.5.0
-langchain==0.2.11
+langchain==0.2.12
+langchain-core==0.2.27
+langchain-community==0.2.11
 langchain-groq==0.1.4
 langchain-openai==0.1.8
+langchain-huggingface==0.0.3
 
 # Vector Databases
 qdrant-client==1.9.0