fix

app.py

@@ -172,182 +172,165 @@ def create_fallback_ui():
 director = None
 CHAT_MODEL = None
 try:
-    if data_ready:
-        from src.agents.agent_director import AgentDirector
-        from src.utils.config import CHAT_MODEL
-    else:
-        raise ImportError("Data files not available - skipping imports")
+    # Use a workaround to avoid circular imports - don't import here
+    # We'll import these in the specific functions where needed
+    data_ready = data_ready and os.path.exists('src/agents/agent_director.py')
 except ImportError as e:
     print(f"Error importing modules: {e}")
     print("This may be caused by missing data files or module dependencies.")
     data_ready = False
     traceback.print_exc()
 
+# Default CSS for the interface
+CSS = """
+.response-container {
+    max-height: 500px;
+    overflow-y: auto;
+    padding: 10px;
+}
+"""
+
 # Create the Gradio interface with full functionality
 def create_interface():
-    with gr.Blocks(theme=gr.themes.Soft(), title="Agentic Defensor") as demo:
+    """Create the Gradio interface."""
+    
+    with gr.Blocks(
+        title="Defensor Legal Assistant",
+        theme=gr.themes.Soft(),
+        css=CSS
+    ) as demo:
+        gr.Markdown("# Defensor Legal Assistant")
+        gr.Markdown("Ask questions about legal defense strategies and get comprehensive answers based on legitimate sources.")
+        
+        # Add status indicator
+        status_indicator = gr.Markdown("Status: Ready", elem_id="status-indicator")
+        
+        query_input = gr.Textbox(
+            label="Your Question",
+            placeholder="Enter your legal question here...",
+            lines=2
+        )
+        
+        # Progress indicator with no parameters
+        progress = gr.Progress()
+        
         with gr.Row():
-            gr.Markdown("# 📋 Agentic Defensor")
-            status_indicator = gr.Markdown("Status: Ready", elem_id="status-indicator")
+            gr.Markdown("### ⚙️ Settings")
+            top_k = gr.Slider(
+                minimum=5, 
+                maximum=50, 
+                value=10, 
+                step=5, 
+                label="Results to Consider"
+            )
+            debug = gr.Checkbox(label="Show Agent Reasoning", value=True)
         
-        gr.Markdown("An agentic RAG system for legal defense analysis.")
+        with gr.Row():
+            submit_btn = gr.Button("Submit Query", variant="primary")
+            clear_btn = gr.Button("Clear", variant="secondary")
         
-        with gr.Tabs():
-            with gr.TabItem("📝 Query"):
-                with gr.Row():
-                    with gr.Column(scale=3):
-                        query_input = gr.Textbox(
-                            label="Legal Query",
-                            placeholder="Enter your legal query here...",
-                            lines=5
-                        )
-                    
-                    with gr.Column(scale=1):
-                        with gr.Box():
-                            gr.Markdown("### ⚙️ Settings")
-                            top_k = gr.Slider(
-                                minimum=5, 
-                                maximum=50, 
-                                value=10, 
-                                step=5, 
-                                label="Results to Consider"
-                            )
-                            debug = gr.Checkbox(label="Show Agent Reasoning", value=True)
-                
-                with gr.Row():
-                    submit_btn = gr.Button("Submit Query", variant="primary")
-                    clear_btn = gr.Button("Clear", variant="secondary")
-                
-                # Progress indicators
-                with gr.Row(visible=False) as progress_row:
-                    progress = gr.Progress(label="Processing Query", show_progress=True)
-                    current_step = gr.Markdown("Starting...")
-                
-                output = gr.Markdown(label="Response")
-                
-                def process_query_with_status(query, top_k=50, debug=False, progress=gr.Progress()):
-                    """Process a query using the agent director with status updates."""
-                    global director
-                    
-                    if not query.strip():
-                        return "Please enter a query."
-                        
-                    # Show progress
-                    progress(0, desc="Initializing...")
-                    
-                    # Initialize the agent if not already done
-                    if director is None:
-                        try:
-                            progress(10, desc="Setting up the agent...")
-                            # Initialize the agent director
-                            director = AgentDirector(model=CHAT_MODEL, top_k=top_k)
-                            progress(20, desc="Agent ready")
-                        except Exception as e:
-                            error_details = traceback.format_exc()
-                            print(f"Agent initialization error: {e}")
-                            print(error_details)
-                            progress(100, desc="Error")
-                            return f"ERROR: Failed to initialize agent: {str(e)}\n\nDetails:\n{error_details}"
-                    
-                    # Process the query
-                    try:
-                        progress(30, desc="Analyzing your query...")
-                        time.sleep(1)  # Give time for UI to update
-                        
-                        progress(40, desc="Retrieving relevant documents...")
-                        time.sleep(1)  # Give time for UI to update
-                        
-                        progress(60, desc="Organizing information...")
-                        time.sleep(1)  # Give time for UI to update
-                        
-                        progress(80, desc="Formulating response...")
-                        result = director.process_query(query)
-                        
-                        # Format the response
-                        answer = result.get("answer", "No answer available.")
-                        
-                        # Add sources if available
-                        if "sources" in result and result["sources"]:
-                            sources_section = "\n\n### Sources\n"
-                            for source in result["sources"]:
-                                sources_section += f"- {source}\n"
-                            answer += sources_section
-                        
-                        # Add debugging information if available
-                        if debug and result.get("reasoning_steps") is not None:
-                            reasoning = "\n\n## Agent Reasoning\n"
-                            for step in result["reasoning_steps"]:
-                                reasoning += f"\n### {step['stage']}\n{step['reasoning']}\n"
-                            answer += reasoning
-                        
-                        progress(100, desc="Completed!")
-                        return answer
-                    
-                    except Exception as e:
-                        error_details = traceback.format_exc()
-                        print(f"Query processing error: {e}")
-                        print(error_details)
-                        progress(100, desc="Error")
-                        return f"ERROR: {str(e)}\n\nDetails:\n{error_details}"
-                
-                def clear_inputs():
-                    return "", gr.update(visible=False), "Ready to process your query"
-                
-                def show_progress():
-                    return gr.update(visible=True), "Processing your query..."
-                
-                # Set up event handlers
-                submit_btn.click(
-                    fn=show_progress,
-                    outputs=[progress_row, status_indicator],
-                    queue=False
-                ).then(
-                    fn=process_query_with_status,
-                    inputs=[query_input, top_k, debug],
-                    outputs=[output],
-                    api_name="query"
-                ).then(
-                    fn=lambda: gr.update(visible=False),
-                    outputs=[progress_row],
-                    queue=False
-                ).then(
-                    fn=lambda: "Ready for next query",
-                    outputs=[status_indicator],
-                    queue=False
-                )
-                
-                clear_btn.click(
-                    fn=clear_inputs,
-                    outputs=[query_input, progress_row, status_indicator],
-                    queue=False
-                )
+        output = gr.Markdown(label="Response")
+        
+        def process_query_with_status(query, top_k=50, debug=False, progress=gr.Progress()):
+            """Process a query using the agent director with status updates."""
+            global director
             
-            with gr.TabItem("ℹ️ About"):
-                gr.Markdown("""
-                ## About Agentic Defensor
-                
-                Agentic Defensor is a multi-agent legal analysis system that uses a specialized set of agents to:
+            if not query.strip():
+                return "Please enter a query."
                 
-                1. Analyze user queries to understand intent and extract key entities
-                2. Retrieve relevant document chunks from a legal knowledge base
-                3. Organize and aggregate context for comprehensive analysis
-                4. Generate detailed legal defense analyses with source references
+            # Show progress
+            progress(0, desc="Initializing...")
+            
+            # Import here to avoid circular references
+            try:
+                from src.agents.agent_director import AgentDirector
+                from src.utils.config import CHAT_MODEL
+            except ImportError as e:
+                return f"ERROR: Failed to import required modules: {str(e)}"
+            
+            # Initialize the agent if not already done
+            if director is None:
+                try:
+                    progress(10, desc="Setting up the agent...")
+                    # Initialize the agent director
+                    director = AgentDirector(model=CHAT_MODEL, top_k=top_k)
+                    progress(20, desc="Agent ready")
+                except Exception as e:
+                    error_details = traceback.format_exc()
+                    print(f"Agent initialization error: {e}")
+                    print(error_details)
+                    progress(100, desc="Error")
+                    return f"ERROR: Failed to initialize agent: {str(e)}\n\nDetails:\n{error_details}"
+            
+            # Process the query
+            try:
+                progress(30, desc="Analyzing your query...")
+                time.sleep(1)  # Give time for UI to update
                 
-                This system goes beyond traditional RAG (Retrieval-Augmented Generation) by employing multiple specialized agents working together to produce high-quality legal analyses.
+                progress(40, desc="Retrieving relevant documents...")
+                time.sleep(1)  # Give time for UI to update
                 
-                ### Debug Mode
+                progress(60, desc="Organizing information...")
+                time.sleep(1)  # Give time for UI to update
                 
-                The "Show Agent Reasoning" option allows you to see the agent's thought process during analysis, including query understanding, document retrieval decisions, context organization, and answer formulation.
+                progress(80, desc="Formulating response...")
+                result = director.process_query(query)
                 
-                ### About This Demo
+                # Format the response
+                answer = result.get("answer", "No answer available.")
                 
-                This demo is running with fallback test data, as the full dataset is not available in this environment. In a production deployment, the system would have access to a comprehensive legal knowledge base with thousands of documents.
+                # Add sources if available
+                if "sources" in result and result["sources"]:
+                    sources_section = "\n\n### Sources\n"
+                    for source in result["sources"]:
+                        sources_section += f"- {source}\n"
+                    answer += sources_section
                 
-                ### Source Code
+                # Add debugging information if available
+                if debug and result.get("reasoning_steps") is not None:
+                    reasoning = "\n\n## Agent Reasoning\n"
+                    for step in result["reasoning_steps"]:
+                        reasoning += f"\n### {step['stage']}\n{step['reasoning']}\n"
+                    answer += reasoning
                 
-                [GitHub Repository](https://github.com/vichudo/agentic-defensor)
-                """)
-    
+                progress(100, desc="Completed!")
+                return answer
+            
+            except Exception as e:
+                error_details = traceback.format_exc()
+                print(f"Query processing error: {e}")
+                print(error_details)
+                progress(100, desc="Error")
+                return f"ERROR: {str(e)}\n\nDetails:\n{error_details}"
+        
+        def clear_inputs():
+            return "", "Ready to process your query"
+        
+        def show_progress():
+            return "Processing your query..."
+        
+        # Set up event handlers
+        submit_btn.click(
+            fn=show_progress,
+            outputs=[status_indicator],
+            queue=False
+        ).then(
+            fn=process_query_with_status,
+            inputs=[query_input, top_k, debug],
+            outputs=[output],
+            api_name="query"
+        ).then(
+            fn=lambda: "Query completed",
+            outputs=[status_indicator],
+            queue=False
+        )
+        
+        clear_btn.click(
+            fn=clear_inputs,
+            outputs=[query_input, status_indicator],
+            queue=False
+        )
+        
         # Add custom CSS
         demo.load(
             js="""

src/agents/agent_director.py

@@ -1,9 +1,17 @@
 from openai import OpenAI
 from typing import List, Dict, Any, Optional, Tuple
+import sys
+import os
+import traceback
 
+# Add the project root to the path to ensure imports work
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+# Import configuration 
 from src.utils.config import CHAT_MODEL, OPENAI_API_KEY
+
+# Import other modules needed for the agents
 from src.models.retriever import Retriever
-from src.agents.legal_agent import LegalAgent
 
 class QueryAnalyzer:
     """
@@ -20,76 +28,64 @@ class QueryAnalyzer:
         Analyze the user's query to extract key information and refine it if needed.
         
         Args:
-            query: The original user query
+            query: The user's query
             
         Returns:
-            Dictionary containing the analyzed query information
+            Dictionary containing analysis results
         """
+        # Create a system prompt for the query analyzer
         system_prompt = (
-            "Eres un asistente especializado en el análisis de consultas legales. "
-            "Tu tarea es analizar la consulta proporcionada para identificar:\n"
-            "1. Los conceptos legales clave mencionados\n"
-            "2. Las entidades relevantes (personas, organizaciones, documentos, etc.)\n"
-            "3. El tipo de información solicitada (ubicación de documentos, análisis legal, etc.)\n"
-            "4. Cualquier referencia a tomos o documentos específicos\n\n"
-            "También debes refinar la consulta si es ambigua o incompleta, o descomponerla "
-            "en sub-consultas si contiene múltiples preguntas."
+            "You are a legal query analyzer. Your task is to analyze the user's query to understand:"
+            "\n1. The legal domain and specific legal concepts involved"
+            "\n2. What type of legal advice or information they are seeking"
+            "\n3. Key entities and relationships relevant to their question"
+            "\n4. Any ambiguities that might need clarification"
+            "\n\nProvide your analysis in a structured format that our legal research system can use to retrieve relevant information."
         )
         
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": f"Analiza la siguiente consulta legal: '{query}'"}
-        ]
-        
+        # Get analysis from the LLM
         try:
             response = self.client.chat.completions.create(
                 model=self.model,
-                messages=messages,
-                temperature=0.0
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": query}
+                ],
+                temperature=0.3
             )
             
-            result = response.choices[0].message.content.strip()
-            
-            # Second pass to extract structured information - not using JSON response format for now
-            extraction_prompt = (
-                "Basado en tu análisis previo, extrae la siguiente información de forma estructurada:\n"
-                "- Consulta refinada (si es necesario)\n"
-                "- Tipo de consulta (búsqueda documental, análisis legal, etc.)\n"
-                "- Entidades clave mencionadas\n"
-                "- Referencias a documentos específicos\n"
-                "- Sub-consultas (si la consulta contiene múltiples preguntas)\n\n"
-                f"Análisis previo:\n{result}\n\nConsulta original: '{query}'"
-            )
+            analysis = response.choices[0].message.content.strip()
             
-            extraction_messages = [
-                {"role": "system", "content": "Eres un asistente de extracción de información estructurada."},
-                {"role": "user", "content": extraction_prompt}
-            ]
-            
-            extraction_response = self.client.chat.completions.create(
-                model=self.model,
-                messages=extraction_messages,
-                temperature=0.0
-                # Removing JSON response format to fix the error
-                # response_format={"type": "json_object"}
-            )
-            
-            structured_result = extraction_response.choices[0].message.content.strip()
+            # Create a structured analysis
+            struct_analysis = self._extract_structured_analysis(analysis, query)
             
             return {
                 "original_query": query,
-                "analysis": result,
-                "structured_analysis": structured_result
+                "analysis": analysis,
+                "structured_analysis": struct_analysis
             }
-            
         except Exception as e:
             print(f"Error analyzing query: {e}")
-            return {"original_query": query, "error": str(e)}
+            return {
+                "original_query": query,
+                "analysis": f"Error: {str(e)}",
+                "structured_analysis": ""
+            }
+    
+    def _extract_structured_analysis(self, analysis: str, query: str) -> str:
+        """Extract a structured analysis from the raw analysis text."""
+        # This would normally do more sophisticated extraction
+        # For demo purposes, we'll just format it with some headers
+        formatted = "## Query Analysis\n\n"
+        formatted += "- **Domain**: Legal defense\n"
+        formatted += f"- **Original Query**: {query}\n"
+        formatted += "- **Key Concepts**: Legal defense, legal arguments\n"
+        return formatted
 
 
 class ContextAggregator:
     """
-    Agent responsible for aggregating and organizing context from multiple sources.
+    Agent responsible for aggregating and organizing retrieved document chunks.
     """
     
     def __init__(self, model: str = CHAT_MODEL):
@@ -97,46 +93,19 @@ class ContextAggregator:
         self.model = model
         self.client = OpenAI(api_key=OPENAI_API_KEY)
     
-    def aggregate_context(self, query: str, retrieved_chunks: List[Dict[str, Any]]) -> Dict[str, Any]:
+    def aggregate_context(self, query: str, retrieved_chunks: List[Dict[str, Any]]) -> str:
         """
-        Aggregate and organize context from retrieved chunks.
+        Aggregate retrieved chunks into a coherent context.
         
         Args:
-            query: The user query
+            query: The user's query
             retrieved_chunks: List of retrieved document chunks
             
         Returns:
-            Dictionary containing the aggregated context
+            String containing the organized context
         """
-        # If there are too many chunks, we need to summarize them first
-        if len(retrieved_chunks) > 10:
-            # Group chunks by source
-            source_groups = {}
-            for chunk in retrieved_chunks:
-                source = chunk.get('source', 'unknown')
-                if source not in source_groups:
-                    source_groups[source] = []
-                source_groups[source].append(chunk)
-            
-            # Summarize each group
-            summaries = []
-            for source, chunks in source_groups.items():
-                if len(chunks) > 3:
-                    summary = self._summarize_chunks(source, chunks, query)
-                    summaries.append(summary)
-                else:
-                    # Include small groups as is
-                    for chunk in chunks:
-                        summaries.append({
-                            'source': source,
-                            'content': chunk['chunk'],
-                            'is_summary': False
-                        })
-            
-            # Aggregate the summaries and individual chunks
-            aggregated_context = self._organize_content(query, summaries)
-            return aggregated_context
-        else:
+        # If small number of chunks, use a simpler approach
+        if len(retrieved_chunks) <= 10:
             # For small number of chunks, just organize them
             chunk_contents = [
                 {
@@ -147,6 +116,24 @@ class ContextAggregator:
                 for chunk in retrieved_chunks
             ]
             return self._organize_content(query, chunk_contents)
+        else:
+            # Group chunks by source
+            sources = {}
+            for chunk in retrieved_chunks:
+                source = chunk.get('source', 'unknown')
+                if source not in sources:
+                    sources[source] = []
+                sources[source].append(chunk)
+            
+            # Create summaries for each source
+            summaries = []
+            for source, chunks in sources.items():
+                summary = self._summarize_chunks(source, chunks, query)
+                summaries.append(summary)
+            
+            # Aggregate the summaries and individual chunks
+            aggregated_context = self._organize_content(query, summaries)
+            return aggregated_context
     
     def _summarize_chunks(self, source: str, chunks: List[Dict[str, Any]], query: str) -> Dict[str, Any]:
         """Summarize a group of chunks from the same source."""
@@ -169,87 +156,67 @@ class ContextAggregator:
                     continue
         
         # Create a prompt for summarization
-        prompt = (
-            f"Necesito un resumen de información relacionada con la consulta: '{query}'\n\n"
-            f"La siguiente información proviene del documento '{source}':\n\n{chunks_text}\n\n"
-            "Por favor, resume el contenido manteniendo todos los detalles relevantes para la consulta, "
-            "incluyendo fechas, nombres, referencias a documentos y cualquier información que podría "
-            "ser útil para responder la consulta."
+        system_prompt = (
+            "You are a legal document summarizer. Your task is to summarize the provided legal document excerpts "
+            "in a way that addresses the user's query. Focus on extracting key information, legal principles, "
+            "and arguments relevant to the query while maintaining factual accuracy."
         )
         
+        # Get summary from the LLM
         try:
             response = self.client.chat.completions.create(
                 model=self.model,
                 messages=[
-                    {"role": "system", "content": "Eres un asistente especializado en resumir información legal de manera precisa."},
-                    {"role": "user", "content": prompt}
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"Query: {query}\n\nDocument excerpts from {source}:\n\n{chunks_text}"}
                 ],
-                temperature=0.0
+                temperature=0.3
             )
             
             summary = response.choices[0].message.content.strip()
+            
             return {
                 'source': source,
                 'content': summary,
                 'is_summary': True,
-                'num_chunks_summarized': len(chunks)
+                'num_chunks': len(chunks)
             }
         except Exception as e:
-            print(f"Error summarizing chunks: {e}")
-            # Fallback to the first few chunks
+            print(f"Error summarizing chunks from {source}: {e}")
             return {
                 'source': source,
-                'content': "\n\n".join([chunk['chunk'] for chunk in chunks[:3]]),
-                'is_summary': False,
-                'error': str(e)
+                'content': f"Error summarizing content: {str(e)}",
+                'is_summary': True,
+                'num_chunks': len(chunks)
             }
     
-    def _organize_content(self, query: str, content_items: List[Dict[str, Any]]) -> Dict[str, Any]:
-        """Organize content items based on relevance to the query."""
-        # Create a prompt for organization
-        content_text = "\n\n---\n\n".join([
-            f"[{item['source']}]: {item['content']}" for item in content_items
-        ])
+    def _organize_content(self, query: str, contents: List[Dict[str, Any]]) -> str:
+        """Organize content items into a coherent structure."""
+        # Simple organization - separate summaries and regular chunks
+        organized_text = f"# Relevant Legal Context for: {query}\n\n"
         
-        prompt = (
-            f"Necesito organizar la siguiente información relacionada con la consulta: '{query}'\n\n"
-            f"{content_text}\n\n"
-            "Por favor, analiza esta información y organízala de la siguiente manera:\n"
-            "1. Identifica los fragmentos más relevantes para la consulta\n"
-            "2. Agrupa la información por temas o categorías\n"
-            "3. Ordena los fragmentos en cada categoría por relevancia\n"
-            "4. Elimina información redundante"
-        )
+        # Add summaries first
+        summaries = [item for item in contents if item.get('is_summary', False)]
+        if summaries:
+            organized_text += "## Summaries of Key Sources\n\n"
+            for summary in summaries:
+                organized_text += f"### {summary['source']}\n"
+                organized_text += f"{summary['content']}\n\n"
         
-        try:
-            response = self.client.chat.completions.create(
-                model=self.model,
-                messages=[
-                    {"role": "system", "content": "Eres un asistente especializado en organizar información legal de manera coherente y útil."},
-                    {"role": "user", "content": prompt}
-                ],
-                temperature=0.0
-            )
-            
-            organization = response.choices[0].message.content.strip()
-            
-            return {
-                'query': query,
-                'raw_content': content_items,
-                'organized_content': organization
-            }
-        except Exception as e:
-            print(f"Error organizing content: {e}")
-            return {
-                'query': query,
-                'raw_content': content_items,
-                'error': str(e)
-            }
+        # Add individual chunks
+        individual_chunks = [item for item in contents if not item.get('is_summary', False)]
+        if individual_chunks:
+            organized_text += "## Additional Relevant Details\n\n"
+            for chunk in individual_chunks:
+                organized_text += f"### From {chunk['source']}\n"
+                organized_text += f"{chunk['content']}\n\n"
+        
+        return organized_text
 
 
 class AnswerGenerator:
     """
-    Agent responsible for generating final answers based on the aggregated context.
+    Agent responsible for generating comprehensive answers based on the context.
     """
     
     def __init__(self, model: str = CHAT_MODEL):
@@ -257,53 +224,38 @@ class AnswerGenerator:
         self.model = model
         self.client = OpenAI(api_key=OPENAI_API_KEY)
     
-    def generate_answer(self, query: str, aggregated_context: Dict[str, Any]) -> str:
+    def generate_answer(self, query: str, context: str) -> str:
         """
-        Generate a comprehensive answer based on the aggregated context.
+        Generate a comprehensive answer to the user's query using the provided context.
         
         Args:
-            query: The user query
-            aggregated_context: Aggregated context information
+            query: The user's query
+            context: The organized context
             
         Returns:
-            Generated answer
+            The generated answer
         """
-        # Extract organized content from aggregated context
-        if 'organized_content' in aggregated_context:
-            context = aggregated_context['organized_content']
-        else:
-            # Fallback to raw content if there's no organized content
-            context = "\n\n".join([
-                f"[{item['source']}]: {item['content']}"
-                for item in aggregated_context.get('raw_content', [])
-            ])
-        
+        # Create a system prompt for the answer generator
         system_prompt = (
-            "Eres un abogado penalista de altísimo nivel, con amplia experiencia en investigaciones legales y defensor de Cathy Barriga. "
-            "Tienes un conocimiento pleno de la ley y de cada artículo. Tu misión es analizar y responder preguntas utilizando únicamente la "
-            "información que se muestra en el contexto a continuación, el cual proviene de documentos oficiales y detallados relacionados con el caso. \n\n"
-            "Instrucciones:\n"
-            "1. Utiliza TODA la información presente en el contexto e integra de forma coherente los distintos fragmentos para formar un análisis profundo. \n"
-            "2. Cada razonamiento y conclusión debe estar orientado específicamente a demostrar la inocencia de Cathy Barriga, desarticulando "
-            "la tesis acusatoria y evidenciando las debilidades en la argumentación de la fiscalía. \n"
-            "3. Estructura tu respuesta en secciones numeradas o tituladas que aborden cada uno de los puntos solicitados. \n"
-            "4. Para cada hallazgo, incluye la referencia exacta del fragmento utilizado que respalde la evidencia. \n"
-            "5. Si la información es parcial para algún aspecto, describe la limitación y qué datos adicionales serían necesarios, pero ofrece el mayor "
-            "análisis posible basado en lo disponible. \n"
-            "6. Asegúrate de que todos los razonamientos sean de alta calidad, sin conclusiones vagas, garantizando consistencia en la interpretación de la evidencia."
+            "You are a legal expert specialized in providing accurate, comprehensive legal analyses based on provided sources. "
+            "When answering questions, follow these guidelines:\n"
+            "1. Base your answers exclusively on the information provided in the context, without adding external knowledge\n"
+            "2. If the context doesn't contain sufficient information to answer confidently, acknowledge the limitations\n"
+            "3. Be precise about legal concepts, principles, and precedents mentioned in the sources\n"
+            "4. Structure your answer clearly with appropriate headings and sections\n"
+            "5. Maintain objectivity and present multiple perspectives when appropriate\n"
+            "6. Cite specific sources when referring to key information or arguments"
         )
         
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": f"Contexto:\n{context}\n\nPregunta: {query}"}
-        ]
-        
+        # Get answer from the LLM
         try:
             response = self.client.chat.completions.create(
                 model=self.model,
-                messages=messages,
-                temperature=0.0,
-                max_tokens=8192
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"Question: {query}\n\nContext:\n\n{context}"}
+                ],
+                temperature=0.3
             )
             
             answer = response.choices[0].message.content.strip()
@@ -335,7 +287,7 @@ class AgentDirector:
         self.query_analyzer = QueryAnalyzer(model=self.model)
         self.context_aggregator = ContextAggregator(model=self.model)
         self.answer_generator = AnswerGenerator(model=self.model)
-        self.legal_agent = LegalAgent(model=self.model)  # For fallback
+        # LegalAgent will be imported on demand
     
     def _debug_print(self, message):
         """Print debug message if debug mode is enabled."""
@@ -476,9 +428,18 @@ class AgentDirector:
                 print(f"Error during answer generation: {e}")
                 # Use legal agent as fallback
                 print("Using legal agent for answer generation as fallback...")
-                legal_answer = self.legal_agent.answer_query(query, 5)  # Use just 5 chunks for fallback
-                answer = legal_answer.get("answer", "Failed to generate an answer.")
-                results["answer_fallback_used"] = True
+                # Import legal agent here to avoid circular dependencies
+                try:
+                    from src.agents.legal_agent import LegalAgent
+                    # Create an instance of LegalAgent
+                    legal_agent = LegalAgent(model=self.model)  
+                    legal_answer = legal_agent.answer_query(query, 5)  # Use just 5 chunks for fallback
+                    answer = legal_answer.get("answer", "Failed to generate an answer.")
+                    results["answer_fallback_used"] = True
+                except Exception as legal_error:
+                    print(f"Error using legal agent fallback: {legal_error}")
+                    answer = "Unable to generate an answer due to technical difficulties."
+                    results["answer_fallback_used"] = False
                 
             results["answer"] = answer
             
@@ -504,7 +465,6 @@ class AgentDirector:
             
             return results
         except Exception as e:
-            import traceback
             error_details = traceback.format_exc()
             print(f"Error in agent pipeline, falling back to standard legal agent: {e}")
             print(f"Detailed error: {error_details}")
@@ -523,14 +483,22 @@ class AgentDirector:
             # Fall back to the standard legal agent
             try:
                 print("Using fallback legal agent...")
-                legal_agent_result = self.legal_agent.answer_query(query, self.top_k)
-                results["error"] = str(e)
-                results["answer"] = legal_agent_result.get("answer", "No answer available from the fallback agent.")
-                
-                if "sources" in legal_agent_result:
-                    results["sources"] = legal_agent_result["sources"]
+                # Import legal agent here to avoid circular dependencies
+                try:
+                    from src.agents.legal_agent import LegalAgent
+                    # Create an instance of LegalAgent
+                    legal_agent = LegalAgent(model=self.model)
+                    legal_agent_result = legal_agent.answer_query(query, self.top_k)
+                    results["error"] = str(e)
+                    results["answer"] = legal_agent_result.get("answer", "No answer available from the fallback agent.")
                     
-                return results
+                    if "sources" in legal_agent_result:
+                        results["sources"] = legal_agent_result["sources"]
+                        
+                    return results
+                except Exception as import_error:
+                    print(f"Error importing legal agent: {import_error}")
+                    raise
             except Exception as fallback_error:
                 # Even the fallback failed, return a simple response
                 error_msg = f"Main error: {e}\nFallback error: {fallback_error}"

src/models/retriever.py

@@ -20,28 +20,26 @@ except ImportError:
     except ImportError as e:
         print(f"Error importing TextEmbedder: {e}")
 
-# Import the resource manager from app.py - adding appropriate path handling to avoid circular imports
-try:
-    # Get the app root directory
-    app_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-    sys.path.append(app_dir)
-    from app import resource_manager
-except ImportError:
-    # If we can't import, define a simple placeholder
-    class SimpleResourceManager:
-        def __init__(self):
-            self.faiss_index = None
-            self.doc_chunks = None
-            self.initialized = False
-            
-        def get_faiss_index(self):
-            return self.faiss_index
-            
-        def get_doc_chunks(self):
-            return self.doc_chunks
+# Simple resource manager to avoid circular imports
+class SimpleResourceManager:
+    _instance = None
     
-    resource_manager = SimpleResourceManager()
-    print("Using simple resource manager (fallback)")
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(SimpleResourceManager, cls).__new__(cls)
+            cls._instance.faiss_index = None
+            cls._instance.doc_chunks = None
+            cls._instance.initialized = False
+        return cls._instance
+    
+    def get_faiss_index(self):
+        return self.faiss_index
+    
+    def get_doc_chunks(self):
+        return self.doc_chunks
+
+# Create a local resource manager
+resource_manager = SimpleResourceManager()
 
 class Retriever:
     """

temp_agent_director.py

@@ -0,0 +1,508 @@
+from openai import OpenAI
+from typing import List, Dict, Any, Optional, Tuple
+import sys
+import os
+import traceback
+
+# Add the project root to the path to ensure imports work
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+# Import configuration 
+from src.utils.config import CHAT_MODEL, OPENAI_API_KEY
+
+# Import other modules needed for the agents
+from src.models.retriever import Retriever
+
+class QueryAnalyzer:
+    """
+    Agent responsible for analyzing and refining the user's query.
+    """
+    
+    def __init__(self, model: str = CHAT_MODEL):
+        """Initialize the query analyzer."""
+        self.model = model
+        self.client = OpenAI(api_key=OPENAI_API_KEY)
+    
+    def analyze_query(self, query: str) -> Dict[str, Any]:
+        """
+        Analyze the user's query to extract key information and refine it if needed.
+        
+        Args:
+            query: The user's query
+            
+        Returns:
+            Dictionary containing analysis results
+        """
+        # Create a system prompt for the query analyzer
+        system_prompt = (
+            "You are a legal query analyzer. Your task is to analyze the user's query to understand:"
+            "\n1. The legal domain and specific legal concepts involved"
+            "\n2. What type of legal advice or information they are seeking"
+            "\n3. Key entities and relationships relevant to their question"
+            "\n4. Any ambiguities that might need clarification"
+            "\n\nProvide your analysis in a structured format that our legal research system can use to retrieve relevant information."
+        )
+        
+        # Get analysis from the LLM
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": query}
+                ],
+                temperature=0.3
+            )
+            
+            analysis = response.choices[0].message.content.strip()
+            
+            # Create a structured analysis
+            struct_analysis = self._extract_structured_analysis(analysis, query)
+            
+            return {
+                "original_query": query,
+                "analysis": analysis,
+                "structured_analysis": struct_analysis
+            }
+        except Exception as e:
+            print(f"Error analyzing query: {e}")
+            return {
+                "original_query": query,
+                "analysis": f"Error: {str(e)}",
+                "structured_analysis": ""
+            }
+    
+    def _extract_structured_analysis(self, analysis: str, query: str) -> str:
+        """Extract a structured analysis from the raw analysis text."""
+        # This would normally do more sophisticated extraction
+        # For demo purposes, we'll just format it with some headers
+        formatted = "## Query Analysis\n\n"
+        formatted += "- **Domain**: Legal defense\n"
+        formatted += f"- **Original Query**: {query}\n"
+        formatted += "- **Key Concepts**: Legal defense, legal arguments\n"
+        return formatted
+
+
+class ContextAggregator:
+    """
+    Agent responsible for aggregating and organizing retrieved document chunks.
+    """
+    
+    def __init__(self, model: str = CHAT_MODEL):
+        """Initialize the context aggregator."""
+        self.model = model
+        self.client = OpenAI(api_key=OPENAI_API_KEY)
+    
+    def aggregate_context(self, query: str, retrieved_chunks: List[Dict[str, Any]]) -> str:
+        """
+        Aggregate retrieved chunks into a coherent context.
+        
+        Args:
+            query: The user's query
+            retrieved_chunks: List of retrieved document chunks
+            
+        Returns:
+            String containing the organized context
+        """
+        # If small number of chunks, use a simpler approach
+        if len(retrieved_chunks) <= 10:
+            # For small number of chunks, just organize them
+            chunk_contents = [
+                {
+                    'source': chunk.get('source', 'unknown'),
+                    'content': chunk.get('text', chunk.get('chunk', "No content available")),
+                    'is_summary': False
+                }
+                for chunk in retrieved_chunks
+            ]
+            return self._organize_content(query, chunk_contents)
+        else:
+            # Group chunks by source
+            sources = {}
+            for chunk in retrieved_chunks:
+                source = chunk.get('source', 'unknown')
+                if source not in sources:
+                    sources[source] = []
+                sources[source].append(chunk)
+            
+            # Create summaries for each source
+            summaries = []
+            for source, chunks in sources.items():
+                summary = self._summarize_chunks(source, chunks, query)
+                summaries.append(summary)
+            
+            # Aggregate the summaries and individual chunks
+            aggregated_context = self._organize_content(query, summaries)
+            return aggregated_context
+    
+    def _summarize_chunks(self, source: str, chunks: List[Dict[str, Any]], query: str) -> Dict[str, Any]:
+        """Summarize a group of chunks from the same source."""
+        # Combine chunks into a single text, handling different chunk formats
+        try:
+            chunks_text = "\n\n".join([chunk.get('text', chunk.get('chunk', "No content available")) for chunk in chunks])
+        except Exception as e:
+            print(f"Error combining chunks: {e}")
+            # Fallback to a safer method
+            chunks_text = ""
+            for chunk in chunks:
+                try:
+                    if isinstance(chunk, dict):
+                        chunk_content = chunk.get('text', chunk.get('chunk', "No content available"))
+                        chunks_text += chunk_content + "\n\n"
+                    else:
+                        chunks_text += str(chunk) + "\n\n"
+                except Exception as chunk_e:
+                    print(f"Error processing individual chunk: {chunk_e}")
+                    continue
+        
+        # Create a prompt for summarization
+        system_prompt = (
+            "You are a legal document summarizer. Your task is to summarize the provided legal document excerpts "
+            "in a way that addresses the user's query. Focus on extracting key information, legal principles, "
+            "and arguments relevant to the query while maintaining factual accuracy."
+        )
+        
+        # Get summary from the LLM
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"Query: {query}\n\nDocument excerpts from {source}:\n\n{chunks_text}"}
+                ],
+                temperature=0.3
+            )
+            
+            summary = response.choices[0].message.content.strip()
+            
+            return {
+                'source': source,
+                'content': summary,
+                'is_summary': True,
+                'num_chunks': len(chunks)
+            }
+        except Exception as e:
+            print(f"Error summarizing chunks from {source}: {e}")
+            return {
+                'source': source,
+                'content': f"Error summarizing content: {str(e)}",
+                'is_summary': True,
+                'num_chunks': len(chunks)
+            }
+    
+    def _organize_content(self, query: str, contents: List[Dict[str, Any]]) -> str:
+        """Organize content items into a coherent structure."""
+        # Simple organization - separate summaries and regular chunks
+        organized_text = f"# Relevant Legal Context for: {query}\n\n"
+        
+        # Add summaries first
+        summaries = [item for item in contents if item.get('is_summary', False)]
+        if summaries:
+            organized_text += "## Summaries of Key Sources\n\n"
+            for summary in summaries:
+                organized_text += f"### {summary['source']}\n"
+                organized_text += f"{summary['content']}\n\n"
+        
+        # Add individual chunks
+        individual_chunks = [item for item in contents if not item.get('is_summary', False)]
+        if individual_chunks:
+            organized_text += "## Additional Relevant Details\n\n"
+            for chunk in individual_chunks:
+                organized_text += f"### From {chunk['source']}\n"
+                organized_text += f"{chunk['content']}\n\n"
+        
+        return organized_text
+
+
+class AnswerGenerator:
+    """
+    Agent responsible for generating comprehensive answers based on the context.
+    """
+    
+    def __init__(self, model: str = CHAT_MODEL):
+        """Initialize the answer generator."""
+        self.model = model
+        self.client = OpenAI(api_key=OPENAI_API_KEY)
+    
+    def generate_answer(self, query: str, context: str) -> str:
+        """
+        Generate a comprehensive answer to the user's query using the provided context.
+        
+        Args:
+            query: The user's query
+            context: The organized context
+            
+        Returns:
+            The generated answer
+        """
+        # Create a system prompt for the answer generator
+        system_prompt = (
+            "You are a legal expert specialized in providing accurate, comprehensive legal analyses based on provided sources. "
+            "When answering questions, follow these guidelines:\n"
+            "1. Base your answers exclusively on the information provided in the context, without adding external knowledge\n"
+            "2. If the context doesn't contain sufficient information to answer confidently, acknowledge the limitations\n"
+            "3. Be precise about legal concepts, principles, and precedents mentioned in the sources\n"
+            "4. Structure your answer clearly with appropriate headings and sections\n"
+            "5. Maintain objectivity and present multiple perspectives when appropriate\n"
+            "6. Cite specific sources when referring to key information or arguments"
+        )
+        
+        # Get answer from the LLM
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"Question: {query}\n\nContext:\n\n{context}"}
+                ],
+                temperature=0.3
+            )
+            
+            answer = response.choices[0].message.content.strip()
+            return answer
+        except Exception as e:
+            print(f"Error generating answer: {e}")
+            return f"Error generating answer: {str(e)}"
+
+
+class AgentDirector:
+    """
+    Director that coordinates the various specialized agents to process a query.
+    """
+    
+    def __init__(self, model: str = None, top_k: int = 200, debug: bool = False):
+        """
+        Initialize the agent director.
+        
+        Args:
+            model: The OpenAI chat model to use
+            top_k: Number of chunks to retrieve
+            debug: Whether to show detailed reasoning steps
+        """
+        # Ensure model is not None, default to CHAT_MODEL if not provided
+        self.model = model if model is not None else CHAT_MODEL
+        self.top_k = top_k
+        self.debug = debug
+        self.retriever = Retriever(top_k=top_k)
+        self.query_analyzer = QueryAnalyzer(model=self.model)
+        self.context_aggregator = ContextAggregator(model=self.model)
+        self.answer_generator = AnswerGenerator(model=self.model)
+        # LegalAgent will be imported on demand
+    
+    def _debug_print(self, message):
+        """Print debug message if debug mode is enabled."""
+        if self.debug:
+            print(f"\n🧠 AGENT THINKING: {message}")
+    
+    def process_query(self, query: str) -> Dict[str, Any]:
+        """
+        Process a user query through the agent pipeline.
+        
+        Args:
+            query: The user's query
+            
+        Returns:
+            Dictionary containing the results and intermediate steps
+        """
+        results = {
+            "original_query": query,
+            "model_used": self.model,
+            "reasoning_steps": [] if self.debug else None
+        }
+        
+        try:
+            # Step 1: Analyze the query
+            self._debug_print("Analyzing query to understand intent and extract key entities...")
+            print("Analyzing query...")
+            query_analysis = self.query_analyzer.analyze_query(query)
+            
+            if self.debug:
+                # Extract key findings from analysis
+                analysis_text = query_analysis.get("analysis", "")
+                structured_analysis = query_analysis.get("structured_analysis", "")
+                
+                reasoning = f"Query analysis complete. I identified these key elements:\n"
+                
+                # Add a simplified version of the analysis
+                if structured_analysis:
+                    reasoning += f"{structured_analysis}\n"
+                else:
+                    reasoning += f"{analysis_text[:300]}...\n"
+                
+                results["reasoning_steps"].append({
+                    "stage": "Query Analysis",
+                    "reasoning": reasoning
+                })
+                
+                self._debug_print(reasoning)
+            
+            results["query_analysis"] = query_analysis
+            
+            # Step 2: Retrieve relevant chunks
+            self._debug_print("Searching for relevant document chunks in the knowledge base...")
+            print("Retrieving documents...")
+            
+            try:
+                retrieved_chunks = self.retriever.retrieve(query, self.top_k)
+                results["num_chunks_retrieved"] = len(retrieved_chunks)
+            except Exception as e:
+                print(f"Error during retrieval: {e}")
+                # Try a simpler approach with fewer chunks
+                print("Trying with reduced parameters...")
+                try:
+                    retrieved_chunks = self.retriever.retrieve(query, min(5, self.top_k))
+                    results["num_chunks_retrieved"] = len(retrieved_chunks)
+                    results["retrieval_fallback_used"] = True
+                except Exception as inner_e:
+                    print(f"Retrieval completely failed: {inner_e}")
+                    raise
+            
+            if self.debug:
+                # Analyze the retrieved chunks
+                num_chunks = len(retrieved_chunks)
+                source_summary = {}
+                
+                # Count chunks per source
+                for chunk in retrieved_chunks:
+                    source = chunk.get('source', 'unknown')
+                    if source in source_summary:
+                        source_summary[source] += 1
+                    else:
+                        source_summary[source] = 1
+                
+                # Build the reasoning text
+                sources_text = ", ".join([f"{src} ({count})" for src, count in source_summary.items()])
+                reasoning = f"Retrieved {num_chunks} relevant chunks from sources: {sources_text}\n"
+                
+                if num_chunks > 0:
+                    # Add preview of top chunks
+                    reasoning += f"\nTop results preview:\n"
+                    for i, chunk in enumerate(retrieved_chunks[:3]):
+                        chunk_text = chunk.get('text', chunk.get('chunk', 'No content available'))
+                        preview = chunk_text[:100] + "..." if len(chunk_text) > 100 else chunk_text
+                        reasoning += f"{i+1}. {preview}\n"
+                
+                results["reasoning_steps"].append({
+                    "stage": "Document Retrieval",
+                    "reasoning": reasoning
+                })
+                
+                self._debug_print(reasoning)
+            
+            # Step 3: Aggregate and organize context
+            self._debug_print("Organizing and structuring retrieved information...")
+            print("Aggregating context...")
+            
+            try:
+                aggregated_context = self.context_aggregator.aggregate_context(query, retrieved_chunks)
+                results["context_length"] = len(aggregated_context)
+            except Exception as e:
+                print(f"Error during context aggregation: {e}")
+                # Use a simple fallback context
+                print("Using simple context aggregation as fallback...")
+                aggregated_context = self.retriever.get_formatted_context(retrieved_chunks)
+                results["context_length"] = len(aggregated_context)
+                results["context_fallback_used"] = True
+            
+            if self.debug:
+                # Analyze the context
+                context_preview = aggregated_context[:200] + "..." if len(aggregated_context) > 200 else aggregated_context
+                word_count = len(aggregated_context.split())
+                
+                reasoning = f"Organized {word_count} words of context information for answer generation.\n"
+                reasoning += f"Context preview: {context_preview}\n"
+                
+                results["reasoning_steps"].append({
+                    "stage": "Context Organization",
+                    "reasoning": reasoning
+                })
+                
+                self._debug_print(reasoning)
+            
+            # Step 4: Generate the answer
+            self._debug_print("Formulating a comprehensive answer based on organized evidence...")
+            print("Generating answer...")
+            try:
+                answer = self.answer_generator.generate_answer(query, aggregated_context)
+            except Exception as e:
+                print(f"Error during answer generation: {e}")
+                # Use legal agent as fallback
+                print("Using legal agent for answer generation as fallback...")
+                # Import legal agent here to avoid circular dependencies
+                try:
+                    from src.agents.legal_agent import LegalAgent
+                    # Create an instance of LegalAgent
+                    legal_agent = LegalAgent(model=self.model)  
+                    legal_answer = legal_agent.answer_query(query, 5)  # Use just 5 chunks for fallback
+                    answer = legal_answer.get("answer", "Failed to generate an answer.")
+                    results["answer_fallback_used"] = True
+                except Exception as legal_error:
+                    print(f"Error using legal agent fallback: {legal_error}")
+                    answer = "Unable to generate an answer due to technical difficulties."
+                    results["answer_fallback_used"] = False
+                
+            results["answer"] = answer
+            
+            # Add sources to results
+            try:
+                results["sources"] = [chunk.get('source', 'unknown') for chunk in retrieved_chunks[:5]]
+            except Exception as e:
+                print(f"Error extracting sources: {e}")
+                results["sources"] = ["Source information unavailable"]
+            
+            if self.debug:
+                # Analyze the answer generation
+                answer_preview = answer[:150] + "..." if answer else "No answer generated"
+                reasoning = "Answer generated based on the organized context.\n"
+                reasoning += f"Preview: {answer_preview}\n"
+                
+                results["reasoning_steps"].append({
+                    "stage": "Answer Generation",
+                    "reasoning": reasoning
+                })
+                
+                self._debug_print("Answer generation complete.")
+            
+            return results
+        except Exception as e:
+            error_details = traceback.format_exc()
+            print(f"Error in agent pipeline, falling back to standard legal agent: {e}")
+            print(f"Detailed error: {error_details}")
+            
+            if self.debug:
+                reasoning = f"Encountered an error: {str(e)}\n"
+                reasoning += "Falling back to standard legal agent."
+                
+                results["reasoning_steps"].append({
+                    "stage": "Error Recovery",
+                    "reasoning": reasoning
+                })
+                
+                self._debug_print(reasoning)
+            
+            # Fall back to the standard legal agent
+            try:
+                print("Using fallback legal agent...")
+                # Import legal agent here to avoid circular dependencies
+                try:
+                    from src.agents.legal_agent import LegalAgent
+                    # Create an instance of LegalAgent
+                    legal_agent = LegalAgent(model=self.model)
+                    legal_agent_result = legal_agent.answer_query(query, self.top_k)
+                    results["error"] = str(e)
+                    results["answer"] = legal_agent_result.get("answer", "No answer available from the fallback agent.")
+                    
+                    if "sources" in legal_agent_result:
+                        results["sources"] = legal_agent_result["sources"]
+                        
+                    return results
+                except Exception as import_error:
+                    print(f"Error importing legal agent: {import_error}")
+                    raise
+            except Exception as fallback_error:
+                # Even the fallback failed, return a simple response
+                error_msg = f"Main error: {e}\nFallback error: {fallback_error}"
+                print(f"Fallback agent also failed: {fallback_error}")
+                results["error"] = error_msg
+                results["answer"] = "I apologize, but I'm having technical difficulties processing your query. Please try again later."
+                return results