feat: Implement multi-agent Chain of Thought system

- Add specialized agents (Planner, Research, Reasoning, Synthesis)

- Modify RAG and LocalRAG agents to use multi-agent CoT

- Add test file for multi-agent system

- Update README with new CoT documentation

- Make local model the default option

Author: jasperan

agentic_rag/README.md

@@ -190,50 +190,88 @@ python rag_agent.py --query "Can you explain the DaGAN Approach proposed in the
 
 ## 2. Chain of Thought (CoT) Support
 
-The system implements Chain of Thought prompting, allowing the LLMs to break down complex queries into steps and show their reasoning process. This feature can be activated in several ways:
+The system implements an advanced multi-agent Chain of Thought system, allowing complex queries to be broken down and processed through multiple specialized agents. This feature enhances the reasoning capabilities of both local and cloud-based models.
 
-### 1. Using the API
+### Multi-Agent System
 
+The CoT system consists of four specialized agents:
+
+1. **Planner Agent**: Breaks down complex queries into clear, manageable steps
+2. **Research Agent**: Gathers and analyzes relevant information from knowledge bases
+3. **Reasoning Agent**: Applies logical analysis to information and draws conclusions
+4. **Synthesis Agent**: Combines multiple pieces of information into a coherent response
+
+### Using CoT
+
+You can activate the multi-agent CoT system in several ways:
+
+1. **Command Line**:
+```bash
+# Using local Mistral model (default)
+python local_rag_agent.py --query "your query" --use-cot
+
+# Using OpenAI model
+python rag_agent.py --query "your query" --use-cot
+```
+
+2. **Testing the System**:
+```bash
+# Test with local model (default)
+python tests/test_new_cot.py
+
+# Test with OpenAI model
+python tests/test_new_cot.py --model openai
+```
+
+3. **API Endpoint**:
 ```http
 POST /query
 Content-Type: application/json
 
 {
-    "query": "your question here",
+    "query": "your query",
     "use_cot": true
 }
 ```
 
-### 2. Using Command Line
+### Example Output
 
-```bash
-# Using local Mistral model with CoT
-python local_rag_agent.py --query "your question" --use-cot
+When CoT is enabled, the system will show:
+- The initial plan for answering the query
+- Research findings for each step
+- Reasoning process and conclusions
+- Final synthesized answer
+- Sources used from the knowledge base
 
-# Using OpenAI with CoT
-python rag_agent.py --query "your question" --use-cot
+Example:
 ```
+Step 1: Planning
+- Break down the technical components
+- Identify key features
+- Analyze implementation details
 
-### 3. Programmatically
+Step 2: Research
+[Research findings for each step...]
 
-```python
-# Initialize agents with CoT enabled
-local_agent = LocalRAGAgent(vector_store, use_cot=True)
-openai_agent = RAGAgent(vector_store, openai_api_key, use_cot=True)
-```
+Step 3: Reasoning
+[Logical analysis and conclusions...]
 
-When CoT is enabled, the system will:
-1. Break down complex queries into logical steps
-2. Show the reasoning process for each step
-3. Use available context more effectively by explaining how it relates to each step
-4. Arrive at more reliable answers through structured thinking
+Final Answer:
+[Comprehensive response synthesized from all steps...]
+
+Sources used:
+- document.pdf (pages: 1, 2, 3)
+- implementation.py
+```
 
-This is particularly useful for:
-- Complex analytical questions
-- Multi-step reasoning problems
-- Questions requiring detailed explanations
-- Queries that need careful consideration of multiple pieces of context
+### Benefits
 
+The multi-agent CoT approach offers several advantages:
+- More structured and thorough analysis of complex queries
+- Better integration with knowledge bases
+- Transparent reasoning process
+- Improved answer quality through specialized agents
+- Works with both local and cloud-based models
 
 ## Annex: API Endpoints
 

agentic_rag/agents/agent_factory.py

@@ -0,0 +1,160 @@
+from typing import List, Dict, Any
+from pydantic import BaseModel, Field
+from langchain_openai import ChatOpenAI
+from langchain.prompts import ChatPromptTemplate
+
+class Agent(BaseModel):
+    """Base agent class with common properties"""
+    name: str
+    role: str
+    description: str
+    
+class PlannerAgent(Agent):
+    """Agent responsible for breaking down problems and planning steps"""
+    def __init__(self, llm):
+        super().__init__(
+            name="Planner",
+            role="Strategic Planner",
+            description="Breaks down complex problems into manageable steps"
+        )
+        self.llm = llm
+        
+    def plan(self, query: str, context: List[Dict[str, Any]] = None) -> str:
+        if context:
+            template = """You are a strategic planning agent. Your role is to break down complex problems into clear, manageable steps.
+            
+            Given the following context and query, create a step-by-step plan to answer the question.
+            Each step should be clear and actionable.
+            
+            Context:
+            {context}
+            
+            Query: {query}
+            
+            Plan:"""
+            context_str = "\n\n".join([f"Context {i+1}:\n{item['content']}" for i, item in enumerate(context)])
+        else:
+            template = """You are a strategic planning agent. Your role is to break down complex problems into clear, manageable steps.
+            
+            Given the following query, create a step-by-step plan to answer the question.
+            Each step should be clear and actionable.
+            
+            Query: {query}
+            
+            Plan:"""
+            context_str = ""
+            
+        prompt = ChatPromptTemplate.from_template(template)
+        messages = prompt.format_messages(query=query, context=context_str)
+        response = self.llm.invoke(messages)
+        return response.content
+
+class ResearchAgent(Agent):
+    """Agent responsible for gathering and analyzing information"""
+    def __init__(self, llm, vector_store):
+        super().__init__(
+            name="Researcher",
+            role="Information Gatherer",
+            description="Gathers and analyzes relevant information from knowledge bases"
+        )
+        self.llm = llm
+        self.vector_store = vector_store
+        
+    def research(self, query: str, step: str) -> List[Dict[str, Any]]:
+        # Query all collections
+        pdf_results = self.vector_store.query_pdf_collection(query)
+        repo_results = self.vector_store.query_repo_collection(query)
+        
+        # Combine results
+        all_results = pdf_results + repo_results
+        
+        if not all_results:
+            return []
+            
+        # Have LLM analyze and summarize findings
+        template = """You are a research agent. Your role is to analyze information and extract relevant details.
+        
+        Given the following research step and context, summarize the key findings that are relevant to this step.
+        
+        Step: {step}
+        
+        Context:
+        {context}
+        
+        Key Findings:"""
+        
+        context_str = "\n\n".join([f"Source {i+1}:\n{item['content']}" for i, item in enumerate(all_results)])
+        prompt = ChatPromptTemplate.from_template(template)
+        messages = prompt.format_messages(step=step, context=context_str)
+        response = self.llm.invoke(messages)
+        
+        return [{"content": response.content, "metadata": {"source": "Research Summary"}}]
+
+class ReasoningAgent(Agent):
+    """Agent responsible for logical reasoning and analysis"""
+    def __init__(self, llm):
+        super().__init__(
+            name="Reasoner",
+            role="Logic and Analysis",
+            description="Applies logical reasoning to information and draws conclusions"
+        )
+        self.llm = llm
+        
+    def reason(self, query: str, step: str, context: List[Dict[str, Any]]) -> str:
+        template = """You are a reasoning agent. Your role is to apply logical analysis to information and draw conclusions.
+        
+        Given the following step, context, and query, apply logical reasoning to reach a conclusion.
+        Show your reasoning process clearly.
+        
+        Step: {step}
+        
+        Context:
+        {context}
+        
+        Query: {query}
+        
+        Reasoning:"""
+        
+        context_str = "\n\n".join([f"Context {i+1}:\n{item['content']}" for i, item in enumerate(context)])
+        prompt = ChatPromptTemplate.from_template(template)
+        messages = prompt.format_messages(step=step, query=query, context=context_str)
+        response = self.llm.invoke(messages)
+        return response.content
+
+class SynthesisAgent(Agent):
+    """Agent responsible for combining information and generating final response"""
+    def __init__(self, llm):
+        super().__init__(
+            name="Synthesizer",
+            role="Information Synthesizer",
+            description="Combines multiple pieces of information into a coherent response"
+        )
+        self.llm = llm
+        
+    def synthesize(self, query: str, reasoning_steps: List[str]) -> str:
+        template = """You are a synthesis agent. Your role is to combine multiple pieces of information into a clear, coherent response.
+        
+        Given the following query and reasoning steps, create a final comprehensive answer.
+        The answer should be well-structured and incorporate the key points from each step.
+        
+        Query: {query}
+        
+        Reasoning Steps:
+        {steps}
+        
+        Final Answer:"""
+        
+        steps_str = "\n\n".join([f"Step {i+1}:\n{step}" for i, step in enumerate(reasoning_steps)])
+        prompt = ChatPromptTemplate.from_template(template)
+        messages = prompt.format_messages(query=query, steps=steps_str)
+        response = self.llm.invoke(messages)
+        return response.content
+
+def create_agents(llm, vector_store=None):
+    """Create and return the set of specialized agents"""
+    return {
+        "planner": PlannerAgent(llm),
+        "researcher": ResearchAgent(llm, vector_store) if vector_store else None,
+        "reasoner": ReasoningAgent(llm),
+        "synthesizer": SynthesisAgent(llm)
+    }