sonika-langchain-bot 0.0.11__tar.gz → 0.0.13__tar.gz

{sonika_langchain_bot-0.0.11/src/sonika_langchain_bot.egg-info → sonika_langchain_bot-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonika-langchain-bot
-Version: 0.0.11
+Version: 0.0.13
 Summary: Agente langchain con LLM
 Author: Erley Blanco Carvajal
 License: MIT License
@@ -10,7 +10,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: langchain==0.3.26
+Requires-Dist: langchain-mcp-adapters==0.1.9
 Requires-Dist: langchain-community==0.3.26
 Requires-Dist: langchain-core==0.3.66
 Requires-Dist: langchain-openai==0.3.24

{sonika_langchain_bot-0.0.11 → sonika_langchain_bot-0.0.13}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="sonika-langchain-bot",
-    version="0.0.11", 
+    version="0.0.13", 
     description="Agente langchain con LLM",
     author="Erley Blanco Carvajal",
     license="MIT License",
@@ -11,7 +11,7 @@ setup(
     packages=find_packages(where="src"),  # Encuentra los paquetes dentro de "src"
     package_dir={"": "src"},  # Indica que los paquetes están en el directorio "src"
     install_requires=[
-        "langchain==0.3.26",
+        "langchain-mcp-adapters==0.1.9",
         "langchain-community==0.3.26",
         "langchain-core==0.3.66",
         "langchain-openai==0.3.24",

sonika_langchain_bot-0.0.13/src/sonika_langchain_bot/langchain_bot_agent.py

@@ -0,0 +1,561 @@
+from typing import Generator, List, Optional, Dict, Any, TypedDict, Annotated
+import asyncio
+from langchain.schema import AIMessage, HumanMessage, BaseMessage
+from langchain_core.messages import ToolMessage
+from langchain.text_splitter import CharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain_community.tools import BaseTool
+from langgraph.graph import StateGraph, END, add_messages
+from langgraph.prebuilt import ToolNode
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_mcp_adapters.client import MultiServerMCPClient
+
+# Import your existing interfaces
+from sonika_langchain_bot.langchain_class import FileProcessorInterface, IEmbeddings, ILanguageModel, Message, ResponseModel
+
+
+class ChatState(TypedDict):
+    """
+    Modern chat state for LangGraph workflow.
+    
+    Attributes:
+        messages: List of conversation messages with automatic message handling
+        context: Contextual information from processed files
+    """
+    messages: Annotated[List[BaseMessage], add_messages]
+    context: str
+
+
+class LangChainBot:
+    """
+    Modern LangGraph-based conversational bot with MCP support.
+    
+    This implementation provides 100% API compatibility with existing ChatService
+    while using modern LangGraph workflows and native tool calling internally.
+    
+    Features:
+        - Native tool calling (no manual parsing)
+        - MCP (Model Context Protocol) support
+        - File processing with vector search
+        - Thread-based conversation persistence
+        - Streaming responses
+        - Backward compatibility with legacy APIs
+    """
+
+    def __init__(self, 
+                 language_model: ILanguageModel, 
+                 embeddings: IEmbeddings, 
+                 instructions: str, 
+                 tools: Optional[List[BaseTool]] = None,
+                 mcp_servers: Optional[Dict[str, Any]] = None,
+                 use_checkpointer: bool = False):
+        """
+        Initialize the modern LangGraph bot with optional MCP support.
+
+        Args:
+            language_model (ILanguageModel): The language model to use for generation
+            embeddings (IEmbeddings): Embedding model for file processing and context retrieval
+            instructions (str): System instructions that will be modernized automatically
+            tools (List[BaseTool], optional): Traditional LangChain tools to bind to the model
+            mcp_servers (Dict[str, Any], optional): MCP server configurations for dynamic tool loading
+            use_checkpointer (bool): Enable automatic conversation persistence using LangGraph checkpoints
+        
+        Note:
+            The instructions will be automatically enhanced with tool descriptions
+            when tools are provided, eliminating the need for manual tool instruction formatting.
+        """
+        # Core components
+        self.language_model = language_model
+        self.embeddings = embeddings
+        self.base_instructions = instructions
+        
+        # Backward compatibility attributes
+        self.chat_history: List[BaseMessage] = []
+        self.vector_store = None
+        
+        # Tool configuration
+        self.tools = tools or []
+        self.mcp_client = None
+        
+        # Initialize MCP servers if provided
+        if mcp_servers:
+            self._initialize_mcp(mcp_servers)
+        
+        # Configure persistence layer
+        self.checkpointer = MemorySaver() if use_checkpointer else None
+        
+        # Prepare model with bound tools for native function calling
+        self.model_with_tools = self._prepare_model_with_tools()
+        
+        # Build modern instruction set with tool descriptions
+        self.instructions = self._build_modern_instructions()
+        
+        # Create the LangGraph workflow
+        self.graph = self._create_modern_workflow()
+        
+        # Legacy compatibility attributes (maintained for API compatibility)
+        self.conversation = None
+        self.agent_executor = None
+
+    def _initialize_mcp(self, mcp_servers: Dict[str, Any]):
+        """
+        Initialize MCP (Model Context Protocol) connections and load available tools.
+        
+        This method establishes connections to configured MCP servers and automatically
+        imports their tools into the bot's tool collection.
+        
+        Args:
+            mcp_servers (Dict[str, Any]): Dictionary of MCP server configurations
+                Example: {
+                    "server_name": {
+                        "command": "python",
+                        "args": ["/path/to/server.py"],
+                        "transport": "stdio"
+                    }
+                }
+        
+        Note:
+            MCP tools are automatically appended to the existing tools list and
+            will be included in the model's tool binding process.
+        """
+        try:
+            self.mcp_client = MultiServerMCPClient(mcp_servers)
+            mcp_tools = asyncio.run(self.mcp_client.get_tools())
+            self.tools.extend(mcp_tools)
+            print(f"✅ MCP initialized: {len(mcp_tools)} tools from {len(mcp_servers)} servers")
+        except Exception as e:
+            print(f"⚠️ MCP initialization error: {e}")
+            self.mcp_client = None
+
+    def _prepare_model_with_tools(self):
+        """
+        Prepare the language model with bound tools for native function calling.
+        
+        This method binds all available tools (both traditional and MCP) to the language model,
+        enabling native function calling without manual parsing or instruction formatting.
+        
+        Returns:
+            The language model with tools bound, or the original model if no tools are available
+        """
+        if self.tools:
+            return self.language_model.model.bind_tools(self.tools)
+        return self.language_model.model
+
+    def _build_modern_instructions(self) -> str:
+        instructions = self.base_instructions
+        
+        if self.tools:
+            tools_description = "\n\n# Available Tools\n\n"
+            
+            for tool in self.tools:
+                tools_description += f"## {tool.name}\n"
+                tools_description += f"**Description:** {tool.description}\n\n"
+                
+                # Opción 1: Tool con args_schema explícito (tu HTTPTool)
+                if hasattr(tool, 'args_schema') and tool.args_schema:
+                    if hasattr(tool.args_schema, '__fields__'):
+                        tools_description += f"**Parameters:**\n"
+                        for field_name, field_info in tool.args_schema.__fields__.items():
+                            required = "**REQUIRED**" if field_info.is_required() else "*optional*"
+                            tools_description += f"- `{field_name}` ({field_info.annotation.__name__}, {required}): {field_info.description}\n"
+                
+                # Opción 2: Tool básico sin args_schema (EmailTool)
+                elif hasattr(tool, '_run'):
+                    tools_description += f"**Parameters:**\n"
+                    import inspect
+                    sig = inspect.signature(tool._run)
+                    for param_name, param in sig.parameters.items():
+                        if param_name != 'self':
+                            param_type = param.annotation.__name__ if param.annotation != inspect.Parameter.empty else 'any'
+                            required = "*optional*" if param.default != inspect.Parameter.empty else "**REQUIRED**"
+                            default_info = f" (default: {param.default})" if param.default != inspect.Parameter.empty else ""
+                            tools_description += f"- `{param_name}` ({param_type}, {required}){default_info}\n"
+                
+                tools_description += "\n"
+            
+            tools_description += ("## Usage Instructions\n"
+                                "- Use the standard function calling format\n"
+                                "- **MUST** provide all REQUIRED parameters\n"
+                                "- Do NOT call tools with empty arguments\n")
+            
+            instructions += tools_description
+
+        return instructions
+
+    def _create_modern_workflow(self) -> StateGraph:
+        """
+        Create a modern LangGraph workflow using idiomatic patterns.
+        
+        This method constructs a state-based workflow that handles:
+        - Agent reasoning and response generation
+        - Automatic tool execution via ToolNode
+        - Context integration from processed files
+        - Error handling and fallback responses
+        
+        Returns:
+            StateGraph: Compiled LangGraph workflow ready for execution
+        """
+        
+        def agent_node(state: ChatState) -> ChatState:
+            """
+            Main agent node responsible for generating responses and initiating tool calls.
+            
+            This node:
+            1. Extracts the latest user message from the conversation state
+            2. Retrieves relevant context from processed files
+            3. Constructs a complete message history for the model
+            4. Invokes the model with tool binding for native function calling
+            5. Returns updated state with the model's response
+            
+            Args:
+                state (ChatState): Current conversation state
+                
+            Returns:
+                ChatState: Updated state with agent response
+            """
+            # Extract the most recent user message
+            last_user_message = None
+            for msg in reversed(state["messages"]):
+                if isinstance(msg, HumanMessage):
+                    last_user_message = msg.content
+                    break
+            
+            if not last_user_message:
+                return state
+            
+            # Retrieve contextual information from processed files
+            context = self._get_context(last_user_message)
+            
+            # Build system prompt with optional context
+            system_content = self.instructions
+            if context:
+                system_content += f"\n\nContext from uploaded files:\n{context}"
+            
+            # Construct message history in OpenAI format
+            messages = [{"role": "system", "content": system_content}]
+            
+            # Add conversation history with simplified message handling
+            for msg in state["messages"]:
+                if isinstance(msg, HumanMessage):
+                    messages.append({"role": "user", "content": msg.content})
+                elif isinstance(msg, AIMessage):
+                    messages.append({"role": "assistant", "content": msg.content or ""})
+                elif isinstance(msg, ToolMessage):
+                    # Convert tool results to user messages for context
+                    messages.append({"role": "user", "content": f"Tool result: {msg.content}"})
+            
+            try:
+                # Invoke model with native tool binding
+                response = self.model_with_tools.invoke(messages)
+                
+                # Return updated state
+                return {
+                    **state,
+                    "context": context,
+                    "messages": [response]  # add_messages annotation handles proper appending
+                }
+                
+            except Exception as e:
+                print(f"Error in agent_node: {e}")
+                # Graceful fallback for error scenarios
+                fallback_response = AIMessage(content="I apologize, but I encountered an error processing your request.")
+                return {
+                    **state,
+                    "context": context,
+                    "messages": [fallback_response]
+                }
+
+        def should_continue(state: ChatState) -> str:
+            """
+            Conditional edge function to determine workflow continuation.
+            
+            Analyzes the last message to decide whether to execute tools or end the workflow.
+            This leverages LangGraph's native tool calling detection.
+            
+            Args:
+                state (ChatState): Current conversation state
+                
+            Returns:
+                str: Next node to execute ("tools" or "end")
+            """
+            last_message = state["messages"][-1]
+            
+            # Check for pending tool calls using native tool calling detection
+            if (isinstance(last_message, AIMessage) and 
+                hasattr(last_message, 'tool_calls') and 
+                last_message.tool_calls):
+                return "tools"
+            
+            return "end"
+
+        # Construct the workflow graph
+        workflow = StateGraph(ChatState)
+        
+        # Add primary agent node
+        workflow.add_node("agent", agent_node)
+        
+        # Add tool execution node if tools are available
+        if self.tools:
+            # ToolNode automatically handles tool execution and result formatting
+            tool_node = ToolNode(self.tools)
+            workflow.add_node("tools", tool_node)
+        
+        # Define workflow edges and entry point
+        workflow.set_entry_point("agent")
+        
+        if self.tools:
+            # Conditional routing based on tool call presence
+            workflow.add_conditional_edges(
+                "agent",
+                should_continue,
+                {
+                    "tools": "tools",
+                    "end": END
+                }
+            )
+            # Return to agent after tool execution for final response formatting
+            workflow.add_edge("tools", "agent")
+        else:
+            # Direct termination if no tools are available
+            workflow.add_edge("agent", END)
+        
+        # Compile workflow with optional checkpointing
+        if self.checkpointer:
+            return workflow.compile(checkpointer=self.checkpointer)
+        else:
+            return workflow.compile()
+
+    # ===== LEGACY API COMPATIBILITY =====
+    
+    def get_response(self, user_input: str) -> ResponseModel:
+        """
+        Generate a response while maintaining 100% API compatibility.
+        
+        This method provides the primary interface for single-turn conversations,
+        maintaining backward compatibility with existing ChatService implementations.
+        
+        Args:
+            user_input (str): The user's message or query
+            
+        Returns:
+            ResponseModel: Structured response containing:
+                - user_tokens: Input token count
+                - bot_tokens: Output token count  
+                - response: Generated response text
+        
+        Note:
+            This method automatically handles tool execution and context integration
+            from processed files while maintaining the original API signature.
+        """
+        # Prepare initial workflow state
+        initial_state = {
+            "messages": self.chat_history + [HumanMessage(content=user_input)],
+            "context": ""
+        }
+        
+        # Execute the LangGraph workflow
+        result = self.graph.invoke(initial_state)
+        
+        # Update internal conversation history
+        self.chat_history = result["messages"]
+        
+        # Extract final response from the last assistant message
+        final_response = ""
+        total_input_tokens = 0
+        total_output_tokens = 0
+        
+        for msg in reversed(result["messages"]):
+            if isinstance(msg, AIMessage) and msg.content:
+                final_response = msg.content
+                break
+        
+        # Extract token usage from response metadata
+        last_message = result["messages"][-1]
+        if hasattr(last_message, 'response_metadata'):
+            token_usage = last_message.response_metadata.get('token_usage', {})
+            total_input_tokens = token_usage.get('prompt_tokens', 0)
+            total_output_tokens = token_usage.get('completion_tokens', 0)
+        
+        return ResponseModel(
+            user_tokens=total_input_tokens,
+            bot_tokens=total_output_tokens,
+            response=final_response
+        )
+    
+    def get_response_stream(self, user_input: str) -> Generator[str, None, None]:
+        """
+        Generate a streaming response for real-time user interaction.
+        
+        This method provides streaming capabilities while maintaining backward
+        compatibility with the original API.
+        
+        Args:
+            user_input (str): The user's message or query
+            
+        Yields:
+            str: Response chunks as they are generated
+            
+        Note:
+            Current implementation streams complete responses. For token-level
+            streaming, consider using the model's native streaming capabilities.
+        """
+        initial_state = {
+            "messages": self.chat_history + [HumanMessage(content=user_input)],
+            "context": ""
+        }
+        
+        accumulated_response = ""
+        
+        # Stream workflow execution
+        for chunk in self.graph.stream(initial_state):
+            # Extract content from workflow chunks
+            if "agent" in chunk:
+                for message in chunk["agent"]["messages"]:
+                    if isinstance(message, AIMessage) and message.content:
+                        # Stream complete responses (can be enhanced for token-level streaming)
+                        accumulated_response = message.content
+                        yield message.content
+        
+        # Update conversation history after streaming completion
+        if accumulated_response:
+            self.chat_history.extend([
+                HumanMessage(content=user_input),
+                AIMessage(content=accumulated_response)
+            ])
+
+    def load_conversation_history(self, messages: List[Message]):
+        """
+        Load conversation history from Django model instances.
+        
+        This method maintains compatibility with existing Django-based conversation
+        storage while preparing the history for modern LangGraph processing.
+        
+        Args:
+            messages (List[Message]): List of Django Message model instances
+                Expected to have 'content' and 'is_bot' attributes
+        """
+        self.chat_history.clear()
+        for message in messages:
+            if message.is_bot:
+                self.chat_history.append(AIMessage(content=message.content))
+            else:
+                self.chat_history.append(HumanMessage(content=message.content))
+
+    def save_messages(self, user_message: str, bot_response: str):
+        """
+        Save messages to internal conversation history.
+        
+        This method provides backward compatibility for manual history management.
+        
+        Args:
+            user_message (str): The user's input message
+            bot_response (str): The bot's generated response
+        """
+        self.chat_history.append(HumanMessage(content=user_message))
+        self.chat_history.append(AIMessage(content=bot_response))
+
+    def process_file(self, file: FileProcessorInterface):
+        """
+        Process and index a file for contextual retrieval.
+        
+        This method maintains compatibility with existing file processing workflows
+        while leveraging FAISS for efficient similarity search.
+        
+        Args:
+            file (FileProcessorInterface): File processor instance that implements getText()
+            
+        Note:
+            Processed files are automatically available for context retrieval
+            in subsequent conversations without additional configuration.
+        """
+        document = file.getText()
+        text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+        texts = text_splitter.split_documents(document)
+
+        if self.vector_store is None:
+            self.vector_store = FAISS.from_texts(
+                [doc.page_content for doc in texts], 
+                self.embeddings
+            )
+        else:
+            self.vector_store.add_texts([doc.page_content for doc in texts])
+
+    def clear_memory(self):
+        """
+        Clear conversation history and processed file context.
+        
+        This method resets the bot to a clean state, removing all conversation
+        history and processed file context.
+        """
+        self.chat_history.clear()
+        self.vector_store = None
+
+    def get_chat_history(self) -> List[BaseMessage]:
+        """
+        Retrieve a copy of the current conversation history.
+        
+        Returns:
+            List[BaseMessage]: Copy of the conversation history
+        """
+        return self.chat_history.copy()
+
+    def set_chat_history(self, history: List[BaseMessage]):
+        """
+        Set the conversation history from a list of BaseMessage instances.
+        
+        Args:
+            history (List[BaseMessage]): New conversation history to set
+        """
+        self.chat_history = history.copy()
+
+    def _get_context(self, query: str) -> str:
+        """
+        Retrieve relevant context from processed files using similarity search.
+        
+        This method performs semantic search over processed file content to find
+        the most relevant information for the current query.
+        
+        Args:
+            query (str): The query to search for relevant context
+            
+        Returns:
+            str: Concatenated relevant context from processed files
+        """
+        if self.vector_store:
+            docs = self.vector_store.similarity_search(query, k=4)
+            return "\n".join([doc.page_content for doc in docs])
+        return ""
+    
+    def process_file(self, file: FileProcessorInterface):
+        """API original - Procesa archivo y lo añade al vector store"""
+        document = file.getText()
+        text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+        texts = text_splitter.split_documents(document)
+
+        if self.vector_store is None:
+            self.vector_store = FAISS.from_texts(
+                [doc.page_content for doc in texts], 
+                self.embeddings
+            )
+        else:
+            self.vector_store.add_texts([doc.page_content for doc in texts])
+
+    def clear_memory(self):
+        """API original - Limpia la memoria de conversación"""
+        self.chat_history.clear()
+        self.vector_store = None
+
+    def get_chat_history(self) -> List[BaseMessage]:
+        """API original - Obtiene el historial completo"""
+        return self.chat_history.copy()
+
+    def set_chat_history(self, history: List[BaseMessage]):
+        """API original - Establece el historial de conversación"""
+        self.chat_history = history.copy()
+
+    def _get_context(self, query: str) -> str:
+        """Obtiene contexto relevante de archivos procesados"""
+        if self.vector_store:
+            docs = self.vector_store.similarity_search(query, k=4)
+            return "\n".join([doc.page_content for doc in docs])
+        return ""

{sonika_langchain_bot-0.0.11 → sonika_langchain_bot-0.0.13/src/sonika_langchain_bot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonika-langchain-bot
-Version: 0.0.11
+Version: 0.0.13
 Summary: Agente langchain con LLM
 Author: Erley Blanco Carvajal
 License: MIT License
@@ -10,7 +10,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: langchain==0.3.26
+Requires-Dist: langchain-mcp-adapters==0.1.9
 Requires-Dist: langchain-community==0.3.26
 Requires-Dist: langchain-core==0.3.66
 Requires-Dist: langchain-openai==0.3.24

{sonika_langchain_bot-0.0.11 → sonika_langchain_bot-0.0.13}/src/sonika_langchain_bot.egg-info/requires.txt

@@ -1,4 +1,4 @@
-langchain==0.3.26
+langchain-mcp-adapters==0.1.9
 langchain-community==0.3.26
 langchain-core==0.3.66
 langchain-openai==0.3.24

sonika_langchain_bot-0.0.11/src/sonika_langchain_bot/langchain_bot_agent.py

@@ -1,281 +0,0 @@
-from typing import Generator, List
-from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, HumanMessagePromptTemplate
-from langchain.schema import AIMessage, HumanMessage, BaseMessage
-from langchain.text_splitter import CharacterTextSplitter
-from langchain_community.vectorstores import FAISS
-from sonika_langchain_bot.langchain_class import FileProcessorInterface, IEmbeddings, ILanguageModel, Message, ResponseModel
-from langgraph.checkpoint.memory import MemorySaver
-from langgraph.prebuilt import create_react_agent
-from langchain_community.tools import BaseTool
-import re
-
-class LangChainBot:
-    """
-    Implementación principal del bot conversacional con capacidades de procesamiento de archivos,
-    memoria de conversación y uso de herramientas personalizadas.
-    """
-
-    def __init__(self, language_model: ILanguageModel, embeddings: IEmbeddings, instructions: str, tools: List[BaseTool]):
-        """
-        Inicializa el bot con el modelo de lenguaje, embeddings y herramientas necesarias.
-
-        Args:
-            language_model (ILanguageModel): Modelo de lenguaje a utilizar
-            embeddings (IEmbeddings): Modelo de embeddings para procesamiento de texto
-            instructions (str): Instrucciones del sistema
-            tools (List[BaseTool]): Lista de herramientas disponibles
-        """
-        self.language_model = language_model
-        self.embeddings = embeddings
-        # Reemplazamos ConversationBufferMemory con una lista simple de mensajes
-        self.chat_history: List[BaseMessage] = []
-        self.memory_agent = MemorySaver()
-        self.vector_store = None
-        self.tools = tools
-        self.instructions = instructions
-        self.add_tools_to_instructions(tools)
-        self.conversation = self._create_conversation_chain()
-        self.agent_executor = self._create_agent_executor()
-
-    def add_tools_to_instructions(self, tools: List[BaseTool]):
-        """Agrega información de las herramientas a las instrucciones base del sistema."""
-        if len(tools) == 0:
-            return
-            
-        # Instrucciones sobre el uso de herramientas
-        tools_instructions = '''\n\nWhen you want to execute a tool, enclose the command with three asterisks and provide all parameters needed.
-Ensure you gather all relevant information from the conversation to use the parameters.
-If information is missing, search online.
-
-This is a list of the tools you can execute:
-'''
-        
-        # Procesar cada herramienta y agregarla a las instrucciones
-        for tool in tools:
-            tool_name = tool.name
-            tool_description = tool.description
-            
-            tools_instructions += f"\nTool Name: {tool_name}\n"
-            tools_instructions += f"Description: {tool_description}\n"
-            
-            # Intentar obtener información de parámetros
-            run_method = getattr(tool, '_run', None)
-            if run_method:
-                try:
-                    import inspect
-                    params = inspect.signature(run_method)
-                    tools_instructions += f"Parameters: {params}\n"
-                except:
-                    tools_instructions += "Parameters: Not available\n"
-            else:
-                tools_instructions += "Parameters: Not available\n"
-            
-            tools_instructions += "---\n"
-        
-        # Agregar las instrucciones de herramientas a las instrucciones base
-        self.instructions += tools_instructions
-        
-
-    def _create_conversation_chain(self):
-        """
-        Crea la cadena de conversación con el prompt template y la memoria.
-        """
-        full_system_prompt = f"{self.instructions}\n\n"
-
-        prompt = ChatPromptTemplate.from_messages([
-            SystemMessagePromptTemplate.from_template(full_system_prompt),
-            MessagesPlaceholder(variable_name="history"),
-            HumanMessagePromptTemplate.from_template("{input}")
-        ])
-
-        # Usando RunnableSequence para reemplazar LLMChain
-        return prompt | self.language_model.model 
-
-    def _create_agent_executor(self):
-        """
-        Crea el ejecutor del agente con las herramientas configuradas.
-
-        Returns:
-            Agent: Agente configurado con las herramientas
-        """
-        return create_react_agent(self.language_model.model, self.tools, checkpointer=self.memory_agent)
-
-    def _getInstruccionTool(self, bot_response):
-        """
-        Extrae las instrucciones para herramientas del texto de respuesta del bot.
-
-        Args:
-            bot_response (str): Respuesta del bot a analizar
-
-        Returns:
-            str: Instrucción extraída o cadena vacía si no se encuentra
-        """
-        patron = r'\*\*\*(.*?)\*\*\*'
-        coincidencia = re.search(patron, bot_response)
-        return coincidencia.group(1).strip() if coincidencia else ''
-
-    def get_response(self, user_input: str) -> ResponseModel:
-        """
-        Genera una respuesta para la entrada del usuario, procesando el contexto y ejecutando herramientas si es necesario.
-
-        Args:
-            user_input (str): Entrada del usuario
-
-        Returns:
-            ResponseModel: Modelo de respuesta con tokens y texto
-        """
-        context = self._get_context(user_input)
-        augmented_input = f"User question: {user_input}"
-        if context:
-            augmented_input = f"Context from attached files:\n{context}\n\nUser question: {user_input}"
-
-        # Usamos el historial de chat directamente
-        bot_response = self.conversation.invoke({
-            "input": augmented_input, 
-            "history": self.chat_history
-        })
-
-        token_usage = bot_response.response_metadata.get('token_usage', {})
-        bot_response_content = bot_response.content
-        
-        instruction_tool = self._getInstruccionTool(bot_response_content)
-
-        if instruction_tool:
-            messages = [HumanMessage(content=instruction_tool)]
-            thread_id = "abc123"
-            config = {"configurable": {"thread_id": thread_id}}
-
-            result_stream = self.agent_executor.stream(
-                {"messages": messages}, config
-            )
-
-            tool_response = ""
-            agent_response = ""
-
-            for response in result_stream:
-                if 'tools' in response:
-                    for message in response['tools']['messages']:
-                        tool_response = message.content
-                if 'agent' in response:
-                    for message in response['agent']['messages']:
-                        agent_response = message.content
-
-            bot_response_content = agent_response if agent_response else tool_response
-
-        user_tokens = token_usage.get('prompt_tokens', 0)
-        bot_tokens = token_usage.get('completion_tokens', 0)
-
-        self.save_messages(user_input, bot_response_content)
-
-        return ResponseModel(user_tokens=user_tokens, bot_tokens=bot_tokens, response=bot_response_content)
-    
-    def get_response_stream(self, user_input: str) -> Generator[str, None, None]:
-        """
-        Genera una respuesta en streaming para la entrada del usuario, procesando el contexto.
-
-        Args:
-            user_input (str): Entrada del usuario
-
-        Yields:
-            str: Fragmentos de la respuesta generada por el modelo en tiempo real
-        """
-        context = self._get_context(user_input)
-        augmented_input = f"User question: {user_input}"
-        if context:
-            augmented_input = f"Context from attached files:\n{context}\n\nUser question: {user_input}"
-
-        # Usamos el historial de chat directamente
-        result_stream = self.conversation.stream({
-            "input": augmented_input, 
-            "history": self.chat_history
-        })
-        
-        full_response = ""
-        for response in result_stream:
-            content = response.content
-            full_response += content
-            yield content
-        
-        # Guardamos los mensajes después del streaming
-        self.save_messages(user_input, full_response)
-
-    def _get_context(self, query: str) -> str:
-        """
-        Obtiene el contexto relevante para una consulta del almacén de vectores.
-
-        Args:
-            query (str): Consulta para buscar contexto
-
-        Returns:
-            str: Contexto encontrado o cadena vacía
-        """
-        if self.vector_store:
-            docs = self.vector_store.similarity_search(query)
-            return "\n".join([doc.page_content for doc in docs])
-        return ""
-
-    def clear_memory(self):
-        """
-        Limpia la memoria de conversación y el almacén de vectores.
-        """
-        self.chat_history.clear()
-        self.vector_store = None
-
-    def load_conversation_history(self, messages: List[Message]):
-        """
-        Carga el historial de conversación previo usando la estructura de mensajes simplificada.
-
-        Args:
-            messages: Lista de objetos Message que representan cada mensaje.
-        """
-        self.chat_history.clear()
-        for message in messages:
-            if message.is_bot:
-                self.chat_history.append(AIMessage(content=message.content))
-            else:
-                self.chat_history.append(HumanMessage(content=message.content))
-
-    def save_messages(self, user_message: str, bot_response: str):
-        """
-        Guarda los mensajes en el historial de conversación.
-
-        Args:
-            user_message (str): Mensaje del usuario
-            bot_response (str): Respuesta del bot
-        """
-        self.chat_history.append(HumanMessage(content=user_message))
-        self.chat_history.append(AIMessage(content=bot_response))
-
-    def process_file(self, file: FileProcessorInterface):
-        """
-        Procesa un archivo y lo añade al almacén de vectores.
-
-        Args:
-            file (FileProcessorInterface): Archivo a procesar
-        """
-        document = file.getText()
-        text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
-        texts = text_splitter.split_documents(document)
-
-        if self.vector_store is None:
-            self.vector_store = FAISS.from_texts([doc.page_content for doc in texts], self.embeddings)
-        else:
-            self.vector_store.add_texts([doc.page_content for doc in texts])
-
-    def get_chat_history(self) -> List[BaseMessage]:
-        """
-        Obtiene el historial completo de la conversación.
-
-        Returns:
-            List[BaseMessage]: Lista de mensajes de la conversación
-        """
-        return self.chat_history.copy()
-
-    def set_chat_history(self, history: List[BaseMessage]):
-        """
-        Establece el historial de conversación.
-
-        Args:
-            history (List[BaseMessage]): Lista de mensajes a establecer
-        """
-        self.chat_history = history.copy()