added base logic

README.md

@@ -9,7 +9,7 @@ rag_agent/
 │   └── rag_system.py         
 ├── knowledge_base/                       # Storage management
 │   ├── chroma.py  # Parent chunks storage (JSON)
-│   └── vector_db_manager.py     # Qdrant vector database setup
+│   └── vector_db_manager.py     
 ├── agent_logic/                # LangGraph agent workflow
 │   ├── edges.py              # Conditional routing logic
 │   ├── graph.py              # Graph construction and compilation

agent/graph.py

@@ -0,0 +1,36 @@
+from langgraph.graph import START, StateGraph, END
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.prebuilt import ToolNode, tools_condition
+from functools import partial
+
+from .state import AgentState
+from .nodes import *
+
+def create_agent_graph(llm, tools) -> StateGraph:
+    """Create the RAG agent graph."""
+    llm_with_tools = llm.with_tools(tools)
+
+    graph = StateGraph(AgentState)
+    checkpointer = MemorySaver()
+
+    tool_node = ToolNode(tools)
+
+    # Nodes
+    graph.add_node("summarize", partial(analyze_chat_and_summarize, llm=llm)) # summarize last 6 messages
+    graph.add_node("analyze_rewrite", partial(analyze_and_rewrite_query, llm=llm)) # analyze and rewrite query
+    graph.add_node("agent", partial(agent_node, llm_with_tools=llm_with_tools)) # generate answer based on retrieved info
+    graph.add_node("tools", tool_node)
+
+    graph.add_edge(START, "summarize")
+    graph.add_edge("summarize", "analyze_rewrite")
+    graph.add_conditional_edges("analyze_rewrite", route_after_rewrite)
+    graph.add_edge("human_input", "analyze_rewrite")
+    graph.add_conditional_edges("agent", tools_condition)
+    graph.add_edge("tools", "agent")
+
+    agent_graph = graph.compile(
+        checkpointer=checkpointer,
+        interrupt_before=["human_input"]
+    )
+
+    return agent_graph

agent/nodes.py

@@ -0,0 +1,97 @@
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage, RemoveMessage
+from typing import Literal
+
+from .state import AgentState, QueryAnalysis
+from .prompts import *
+
+def analyze_chat_and_summarize(state: AgentState, llm):
+    """
+    Analyzes chat history and summarizes key points for context.
+    """
+    if len(state["messages"]) < 4:  # Need some history to summarize
+        return {"conversation_summary": ""}
+
+    # Extract relevant messages (excluding current query and system messages)
+    relevant_msgs = [
+        msg for msg in state["messages"][:-1]  # Exclude current query
+        if isinstance(msg, (HumanMessage, AIMessage))
+        and not getattr(msg, "tool_calls", None)
+    ]
+
+    if not relevant_msgs:
+        return {"conversation_summary": ""}
+
+    summary_prompt = """**Summarize the key topics and context from this conversation concisely (1-2 sentences max).**
+    Discard irrelevant information, such as misunderstandings or off-topic queries/responses.
+    If there are no key topics, return an empty string.
+
+    """
+    for msg in relevant_msgs[-6:]:  # Last 6 messages for context
+        role = "User" if isinstance(msg, HumanMessage) else "Assistant"
+        summary_prompt += f"{role}: {msg.content}\n"
+
+    summary_prompt += "\nBrief Summary:"
+    summary_response = llm.with_config(temperature=0.3).invoke([SystemMessage(content=summary_prompt)])
+    return {"conversation_summary": summary_response.content}
+
+def analyze_and_rewrite_query(state: AgentState, llm):
+    """
+    Analyzes user query and rewrites it for clarity, optionally using conversation context.
+    """
+    last_message = state["messages"][-1]
+    conversation_summary = state.get("conversation_summary", "")
+
+    context_section = (
+        f"**Conversation Context:**\n{conversation_summary}"
+        if conversation_summary.strip()
+        else "**Conversation Context:**\n[First query in conversation]"
+    )
+
+    # Create analysis prompt
+    query_analysis_prompt = get_query_analysis_prompt(last_message.content, conversation_summary)
+
+    llm_with_structure = llm.with_config(temperature=0.3).with_structured_output(QueryAnalysis)
+    response = llm_with_structure.invoke([SystemMessage(content=query_analysis_prompt)])
+
+    if response.is_clear:
+        # Remove all non-system messages
+        delete_all = [
+            RemoveMessage(id=m.id)
+            for m in state["messages"]
+            if not isinstance(m, SystemMessage)
+        ]
+
+        # Format rewritten query
+        rewritten = (
+            "\n".join([f"{i+1}. {q}" for i, q in enumerate(response.questions)])
+            if len(response.questions) > 1
+            else response.questions[0]
+        )
+        return {
+            "questionIsClear": True,
+            "messages": delete_all + [HumanMessage(content=rewritten)]
+        }
+    else:
+        clarification = response.clarification_needed or "I need more information to understand your question."
+        return {
+            "questionIsClear": False,
+            "messages": [AIMessage(content=clarification)]
+        }
+
+def human_input_node(state: AgentState):
+    """Placeholder node for human-in-the-loop interruption"""
+    return {}
+
+def route_after_rewrite(state: AgentState) -> Literal["agent", "human_input"]:
+    """Route to agent if question is clear, otherwise wait for human input"""
+    return "agent" if state.get("questionIsClear", False) else "human_input"
+
+def agent_node(state: AgentState, llm_with_tools):
+    """Main agent node that processes queries using tools"""
+    system_prompt = get_system_prompt()
+    messages = [system_prompt] + state["messages"]
+    response = llm_with_tools.invoke(messages)
+    return {"messages": [response]}
+
+if __name__ == "__main__":
+    pass

agent/prompts.py

@@ -0,0 +1,75 @@
+from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
+
+def get_system_prompt() -> SystemMessage:
+    """Generate the system prompt for the RAG agent."""
+    return SystemMessage(content="""
+You are an intelligent assistant that MUST use the available tools to answer questions.
+
+**MANDATORY WORKFLOW — Follow these steps for EVERY question:**
+1. **Call `search_chroma`** with the user's query (K = 3–7) to find the most relevant chunks in the Chroma vector store.
+2. **Review the retrieved chunks** and identify the relevant ones. The chunks will contain content and metadata (such as `parent_id` and `source`).
+3. **If additional context is needed**, retrieve more details from the source tools (e.g., Wikipedia or Arxiv) to provide the full answer.
+4. **Use metadata** such as `source` and `parent_id` to help clarify or support the answer when applicable.
+5. **Answer using ONLY the retrieved information**:
+   - Combine relevant chunks and use metadata (e.g., citation sources) as needed to clarify or support the response.
+6. **If no relevant information is found**, rewrite the query into an **answer-focused declarative statement** and search again **only once** using `search_chroma`.
+7. **Return the final answer** derived from the most relevant results.
+""")
+
+def get_conversation_summary_prompt(messages):
+    """Generate a prompt for conversation summarization."""
+    summary_prompt = """**Summarize the key topics and context from this conversation concisely (1-2 sentences max).**
+    Discard irrelevant information, such as misunderstandings or off-topic queries/responses.
+    If there are no key topics, return an empty string.
+
+    """
+    
+    for msg in messages[-6:]:
+        role = "User" if isinstance(msg, HumanMessage) else "Assistant"
+        summary_prompt += f"{role}: {msg.content}\n"
+
+    summary_prompt += "\n**Brief Summary:**"
+    return summary_prompt
+
+def get_query_analysis_prompt(query: str, conversation_summary: str = "") -> str:
+    """Generate a prompt for query analysis and rewriting."""
+    context_section = (
+        f"**Conversation Context:**\n{conversation_summary}"
+        if conversation_summary.strip()
+        else "**Conversation Context:**\n[First query in conversation]"
+    )
+
+    return f"""
+**Rewrite the user's query** to be clear, self-contained, and optimized for information retrieval.
+
+**User Query:**
+"{query}"
+
+{context_section}
+
+**Instructions:**
+
+1. **Resolve references for follow-ups:** 
+   - If the query uses pronouns or refers to previous topics, use the context to make it self-contained.
+
+2. **Ensure clarity for new queries:** 
+   - Make the query specific, concise, and unambiguous.
+
+3. **Correct errors and interpret intent:** 
+   - If the query is grammatically incorrect, contains typos, or has abbreviations, correct it and infer the intended meaning.
+
+4. **Split only when necessary:** 
+   - If multiple distinct questions exist, split into **up to 3 focused sub-queries** to avoid over-segmentation.
+   - Each sub-query must still be meaningful on its own.
+
+5. **Optimize for search:** 
+   - Use **keywords, proper nouns, numbers, dates, and technical terms**. 
+   - Remove conversational filler, vague words, and redundancies.
+   - Make the query concise and focused for information retrieval.
+
+6. **Mark as unclear if intent is missing:** 
+   - This includes nonsense, gibberish, insults, or statements without an apparent question.
+"""
+                
+if __name__ == "__main__":
+    pass

agent/state.py

@@ -0,0 +1,19 @@
+from typing import TypedDict, Annotated, Sequence, Optional, List
+from langchain_core.messages import AnyMessage, HumanMessage, AIMessage, SystemMessage, ToolMessage
+from langgraph.graph.message import add_messages
+from pydantic import BaseModel, Field
+
+
+class AgentState(TypedDict):
+    messages: Annotated[Sequence[AnyMessage], add_messages]
+    questionIsClear: bool
+    conversation_summary: str = ""
+    
+class QueryAnalysis(BaseModel):
+    """Structured output for query analysis"""
+    is_clear: bool = Field(description="Indicates if the user's question is clear and answerable")
+    questions: List[str] = Field(description="List of rewritten, self-contained questions")
+    clarification_needed: str = Field(description="Explanation if the question is unclear")
+
+if __name__ == "__main__":
+    pass

agent/tools.py

@@ -0,0 +1,99 @@
+import json
+from typing import List
+from langchain_core.tools import tool
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_chroma import Chroma
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.document_loaders import WikipediaLoader, ArxivLoader 
+
+
+from config import configs
+
+
+def intialize_chroma_vectorstore():
+    """Initialize and return the Chroma vector store."""
+    dense_embeddings = HuggingFaceEmbeddings(
+        model_name=configs["EMBEDDING_MODEL_NAME"]
+    )
+
+    vectorstore = Chroma(
+        persist_directory=configs["PERSIST_PATH"],
+        embedding_function=dense_embeddings,
+        collection_name=configs["COLLECTION_NAME"]
+    )
+    return vectorstore
+
+
+@tool
+def search_chroma(vectorstore: Chroma, query: str, k: int = 5) -> List[dict]:
+    """Search for the top K most relevant chunks from Chroma vector store.
+
+    Args:
+        query: Search query string
+        k: Number of results to return
+    """
+    try:
+        results = vectorstore.similarity_search(query, k=k, score_threshold=0.7)
+        
+        return [
+            {
+                "content": doc.page_content,
+                "parent_id": doc.metadata.get("parent_id", ""),
+                "source": doc.metadata.get("source", "")
+            }
+            for doc in results
+        ]
+    
+    except Exception as e:
+        print(f"Error searching chunks: {e}")
+        return []
+    
+@tool 
+def wikipedia_search(query: str) -> dict:
+    """Search Wikipedia for a query and return up to 3 results.
+    Args:
+        query: The search query.
+    Returns:
+        dict with key 'wiki_results', containing a list of search results with
+        'title', 'url', and 'snippet'.
+    """
+    try:
+        search_docs = WikipediaLoader(query=query, load_max_docs=3).load()
+        results = [
+            {
+                "title": doc.metadata.get("title", ""),
+                "url": doc.metadata.get("url", ""),
+                "snippet": doc.page_content,
+            }
+            for doc in search_docs
+        ]
+        return {"wiki_results": results}
+    except Exception as e:
+        return {"wiki_results": f"Error retrieving results: {str(e)}"}
+
+@tool
+def arxiv_search(query: str) -> dict:
+    """Search Arxiv for a query and return up to 3 results.
+    Args:
+        query: The search query.
+    Returns:
+        dict with key 'arxiv_results', containing a list of search results with
+        'title', 'url', and 'snippet'.
+    """
+    try:
+        search_docs = ArxivLoader(query=query, load_max_docs=3).load()
+        results = [
+            {
+                "title": doc.metadata.get("title", ""),
+                "url": doc.metadata.get("url", ""),
+                "snippet": doc.page_content,
+            }
+            for doc in search_docs
+        ]
+        return {"arxiv_results": results}
+    except Exception as e:
+        return {"arxiv_results": f"Error retrieving results: {str(e)}"}
+    
+    
+if __name__ == "__main__":
+    pass

core/rag_agent.py

@@ -0,0 +1,29 @@
+import uuid
+from langchain_google_genai import ChatGoogleGenerativeAI
+import config
+from agent.tools import *
+from agent.graph import create_agent_graph
+
+class RAGAgent:
+    
+    def __init__(self, collection_name=config.CHILD_COLLECTION):
+        self.collection_name = collection_name
+        self.retriever = intialize_chroma_vectorstore()
+        self.thread_id = str(uuid.uuid4())
+        
+        self.llm = ChatGoogleGenerativeAI(model=config.LLM_MODEL, temperature=config.LLM_TEMPERATURE)
+        tools = []
+        self.agent_graph = create_agent_graph(self.llm, tools)
+        
+    def get_config(self):
+        return {"configurable": {"thread_id": self.thread_id}}
+    
+    def reset_thread(self):
+        try:
+            self.agent_graph.checkpointer.delete_thread(self.thread_id)
+        except Exception as e:
+            print(f"Warning: Could not delete thread {self.thread_id}: {e}")
+        self.thread_id = str(uuid.uuid4())
+
+if __name__ == "__main__":
+    pass

knowledge_base/chroma.py

@@ -50,8 +50,5 @@ if __name__ == "__main__":
         persist_directory=configs["PERSIST_PATH"]
     )
 
-    # Explicitly persist the data for immediate use
-    vectorstore.persist()
-
     print("✅ Success: Chroma vector store created and data persisted.")
     print(f"The vector database is now ready for query using the collection: '{configs['COLLECTION_NAME']}'")

knowledge_base/embeddings.py

@@ -1,22 +0,0 @@
-from langchain_huggingface import HuggingFaceEmbeddings
-from langchain_chroma import Chroma
-
-# 1. Define the custom embedding object
-dense_embeddings = HuggingFaceEmbeddings(
-    model_name="sentence-transformers/all-mpnet-base-v2"
-)
-
-# 2. Initialize the LangChain Chroma vector store, passing the embeddings
-vectorstore = Chroma.from_documents(
-    documents=["./docs/markdowns"],  # Placeholder for actual documents
-    embedding=dense_embeddings,
-    collection_name="langchain_mpnet_collection",
-    persist_directory="./knowledge_base/chroma_data" 
-)
-
-# 3. Save the database (essential for persistence)
-vectorstore.persist()
-print("LangChain Chroma vector store created with custom embeddings and persisted.")
-
-if __name__ == "__main__":
-    pass

requirements.txt

@@ -12,4 +12,5 @@ pymupdf4llm
 langchain-community
 langchain_text_splitters
 pymupdf-layout
-sentence_transformers
+sentence_transformers
+gradio

testing_main.py

@@ -0,0 +1,11 @@
+from config import configs
+from knowledge_base.test_retrieval import PERSIST_PATH, EMBEDDING_MODEL_NAME, COLLECTION_NAME
+
+if __name__ == "__main__":
+    print("Testing configuration values...")
+    for key, value in configs.items():
+        print(f"{key}: {value}")
+    print("✅ Configuration test completed successfully.")
+    print(f"PERSIST_PATH: {PERSIST_PATH}")
+    print(f"EMBEDDING_MODEL_NAME: {EMBEDDING_MODEL_NAME}")
+    print(f"COLLECTION_NAME: {COLLECTION_NAME}")

ui/gradio_components.py

@@ -0,0 +1,91 @@
+import gradio as gr
+from core.chat_interface import ChatInterface
+from core.document_manager import DocumentManager
+from core.rag_system import RAGSystem
+
+def create_gradio_ui():
+    rag_system = RAGSystem()
+    rag_system.initialize()
+    
+    doc_manager = DocumentManager(rag_system)
+    chat_interface = ChatInterface(rag_system)
+    
+    def format_file_list():
+        files = doc_manager.get_markdown_files()
+        if not files:
+            return "📭 No documents available in the knowledge base"
+        return "\n".join([f"{f}" for f in files])
+    
+    def upload_handler(files, progress=gr.Progress()):
+        if not files:
+            return None, format_file_list()
+            
+        added, skipped = doc_manager.add_documents(
+            files, 
+            progress_callback=lambda p, desc: progress(p, desc=desc)
+        )
+        
+        gr.Info(f"✅ Added: {added} | Skipped: {skipped}")
+        return None, format_file_list()
+    
+    def clear_handler():
+        doc_manager.clear_all()
+        gr.Info(f"🗑️ Removed all documents")
+        return format_file_list()
+    
+    def chat_handler(msg, hist):
+        return chat_interface.chat(msg, hist)
+    
+    def clear_chat_handler():
+        chat_interface.clear_session()
+    
+    with gr.Blocks(title="Agentic RAG") as demo:
+        
+        with gr.Tab("Documents", elem_id="doc-management-tab"):
+            gr.Markdown("## Add New Documents")
+            gr.Markdown("Upload PDF or Markdown files. Duplicates will be automatically skipped.")
+            
+            files_input = gr.File(
+                label="Drop PDF or Markdown files here",
+                file_count="multiple",
+                type="filepath",
+                height=200,
+                show_label=False
+            )
+            
+            add_btn = gr.Button("Add Documents", variant="primary", size="md")
+            
+            gr.Markdown("## Current Documents in the Knowledge Base")
+            file_list = gr.Textbox(
+                value=format_file_list(),
+                interactive=False,
+                lines = 7,
+                max_lines=10,
+                elem_id="file-list-box",
+                show_label=False
+            )
+            
+            with gr.Row():
+                refresh_btn = gr.Button("Refresh", size="md")
+                clear_btn = gr.Button("Clear All", variant="stop", size="md")
+            
+            add_btn.click(
+                upload_handler, 
+                [files_input], 
+                [files_input, file_list], 
+                show_progress="corner"
+            )
+            refresh_btn.click(format_file_list, None, file_list)
+            clear_btn.click(clear_handler, None, file_list)
+        
+        with gr.Tab("Chat"):
+            chatbot = gr.Chatbot(
+                height=600, 
+                placeholder="Ask me anything about your documents!",
+                show_label=False
+            )
+            chatbot.clear(clear_chat_handler)
+            
+            gr.ChatInterface(fn=chat_handler, chatbot=chatbot)
+    
+    return demo