sonika-langchain-bot 0.0.11__py3-none-any.whl → 0.0.12__py3-none-any.whl

sonika_langchain_bot/langchain_bot_agent.py

@@ -1,232 +1,422 @@
-from typing import Generator, List
-from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, HumanMessagePromptTemplate
+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 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
+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:
     """
-    Implementación principal del bot conversacional con capacidades de procesamiento de archivos,
-    memoria de conversación y uso de herramientas personalizadas.
+    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: List[BaseTool]):
+    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):
         """
-        Inicializa el bot con el modelo de lenguaje, embeddings y herramientas necesarias.
+        Initialize the modern LangGraph bot with optional MCP support.
 
         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
+            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
-        # Reemplazamos ConversationBufferMemory con una lista simple de mensajes
+        self.base_instructions = instructions
+        
+        # Backward compatibility attributes
         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
+        # 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 _create_conversation_chain(self):
+    def _initialize_mcp(self, mcp_servers: Dict[str, Any]):
         """
-        Crea la cadena de conversación con el prompt template y la memoria.
+        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.
         """
-        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):
+        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):
         """
-        Crea el ejecutor del agente con las herramientas configuradas.
-
+        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:
-            Agent: Agente configurado con las herramientas
+            The language model with tools bound, or the original model if no tools are available
         """
-        return create_react_agent(self.language_model.model, self.tools, checkpointer=self.memory_agent)
+        if self.tools:
+            return self.language_model.model.bind_tools(self.tools)
+        return self.language_model.model
 
-    def _getInstruccionTool(self, bot_response):
+    def _build_modern_instructions(self) -> str:
         """
-        Extrae las instrucciones para herramientas del texto de respuesta del bot.
-
-        Args:
-            bot_response (str): Respuesta del bot a analizar
-
+        Build modern system instructions with automatic tool descriptions.
+        
+        This method enhances the base instructions with professional tool descriptions
+        that leverage native function calling capabilities, eliminating the need for
+        manual tool instruction formatting.
+        
         Returns:
-            str: Instrucción extraída o cadena vacía si no se encuentra
+            str: Complete system instructions including tool descriptions
         """
-        patron = r'\*\*\*(.*?)\*\*\*'
-        coincidencia = re.search(patron, bot_response)
-        return coincidencia.group(1).strip() if coincidencia else ''
+        instructions = self.base_instructions
+        
+        if self.tools:
+            tools_description = "\n\nYou have access to the following tools:\n"
+            for tool in self.tools:
+                tools_description += f"- {tool.name}: {tool.description}\n"
+            
+            tools_description += ("\nCall these tools when needed using the standard function calling format. "
+                                "You can call multiple tools in sequence if necessary to fully answer the user's question.")
+            
+            instructions += tools_description
+        
+        return instructions
 
-    def get_response(self, user_input: str) -> ResponseModel:
+    def _create_modern_workflow(self) -> StateGraph:
         """
-        Genera una respuesta para la entrada del usuario, procesando el contexto y ejecutando herramientas si es necesario.
-
-        Args:
-            user_input (str): Entrada del usuario
-
+        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:
-            ResponseModel: Modelo de respuesta con tokens y texto
+            StateGraph: Compiled LangGraph workflow ready for execution
         """
-        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}}
+        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"
 
-            result_stream = self.agent_executor.stream(
-                {"messages": messages}, config
+        # 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()
 
-            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)
+    # ===== LEGACY API COMPATIBILITY =====
     
-    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
+    def get_response(self, user_input: str) -> ResponseModel:
         """
-        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
-        })
+        Generate a response while maintaining 100% API compatibility.
         
-        full_response = ""
-        for response in result_stream:
-            content = response.content
-            full_response += content
-            yield content
+        This method provides the primary interface for single-turn conversations,
+        maintaining backward compatibility with existing ChatService implementations.
         
-        # 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
-
+            user_input (str): The user's message or query
+            
         Returns:
-            str: Contexto encontrado o cadena vacía
+            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.
         """
-        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):
+        # 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]:
         """
-        Limpia la memoria de conversación y el almacén de vectores.
+        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.
         """
-        self.chat_history.clear()
-        self.vector_store = None
+        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]):
         """
-        Carga el historial de conversación previo usando la estructura de mensajes simplificada.
-
+        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: Lista de objetos Message que representan cada mensaje.
+            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:
@@ -237,45 +427,296 @@ This is a list of the tools you can execute:
 
     def save_messages(self, user_message: str, bot_response: str):
         """
-        Guarda los mensajes en el historial de conversación.
-
+        Save messages to internal conversation history.
+        
+        This method provides backward compatibility for manual history management.
+        
         Args:
-            user_message (str): Mensaje del usuario
-            bot_response (str): Respuesta del bot
+            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):
         """
-        Procesa un archivo y lo añade al almacén de vectores.
-
+        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): Archivo a procesar
+            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)
+            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]:
         """
-        Obtiene el historial completo de la conversación.
+        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:
-            List[BaseMessage]: Lista de mensajes de la conversación
+            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 ""
+
+    # ===== MODERN ENHANCED CAPABILITIES =====
+    
+    def get_response_with_thread(self, user_input: str, thread_id: str) -> ResponseModel:
         """
-        Establece el historial de conversación.
+        Generate response with automatic conversation persistence using thread IDs.
+        
+        This method leverages LangGraph's checkpointing system to automatically
+        persist and retrieve conversation state based on thread identifiers.
+        
+        Args:
+            user_input (str): The user's message or query
+            thread_id (str): Unique identifier for the conversation thread
+            
+        Returns:
+            ResponseModel: Structured response with token usage and content
+            
+        Raises:
+            ValueError: If checkpointer is not configured during initialization
+            
+        Note:
+            Each thread_id maintains independent conversation state, enabling
+            multiple concurrent conversations per user or session.
+        """
+        if not self.checkpointer:
+            raise ValueError("Checkpointer not configured. Initialize with use_checkpointer=True")
+        
+        config = {"configurable": {"thread_id": thread_id}}
+        
+        initial_state = {
+            "messages": [HumanMessage(content=user_input)],
+            "context": ""
+        }
+        
+        result = self.graph.invoke(initial_state, config=config)
+        
+        # Extract final response
+        final_response = ""
+        for msg in reversed(result["messages"]):
+            if isinstance(msg, AIMessage) and msg.content:
+                final_response = msg.content
+                break
+        
+        # Extract token usage
+        token_usage = {}
+        last_message = result["messages"][-1]
+        if hasattr(last_message, 'response_metadata'):
+            token_usage = last_message.response_metadata.get('token_usage', {})
+        
+        return ResponseModel(
+            user_tokens=token_usage.get('prompt_tokens', 0),
+            bot_tokens=token_usage.get('completion_tokens', 0),
+            response=final_response
+        )
+
+    def stream_with_thread(self, user_input: str, thread_id: str) -> Generator[Dict[str, Any], None, None]:
+        """
+        Stream response with automatic conversation persistence.
+        
+        This method combines streaming capabilities with thread-based persistence,
+        allowing real-time response generation while maintaining conversation state.
+        
+        Args:
+            user_input (str): The user's message or query
+            thread_id (str): Unique identifier for the conversation thread
+            
+        Yields:
+            Dict[str, Any]: Workflow execution chunks containing intermediate states
+            
+        Raises:
+            ValueError: If checkpointer is not configured during initialization
+        """
+        if not self.checkpointer:
+            raise ValueError("Checkpointer not configured. Initialize with use_checkpointer=True")
+        
+        config = {"configurable": {"thread_id": thread_id}}
+        
+        initial_state = {
+            "messages": [HumanMessage(content=user_input)],
+            "context": ""
+        }
+        
+        for chunk in self.graph.stream(initial_state, config=config):
+            yield chunk
 
+    def get_mcp_status(self) -> Dict[str, Any]:
+        """
+        Retrieve the current status of MCP (Model Context Protocol) integration.
+        
+        This method provides diagnostic information about MCP server connections
+        and tool availability for monitoring and debugging purposes.
+        
+        Returns:
+            Dict[str, Any]: MCP status information containing:
+                - mcp_enabled: Whether MCP is active
+                - servers: List of connected server names
+                - tools_count: Number of MCP-sourced tools
+                - total_tools: Total number of available tools
+        """
+        if not self.mcp_client:
+            return {"mcp_enabled": False, "servers": [], "tools_count": 0}
+        
+        mcp_tools_count = len([
+            tool for tool in self.tools 
+            if hasattr(tool, '__module__') and tool.__module__ and 'mcp' in tool.__module__
+        ])
+        
+        return {
+            "mcp_enabled": True,
+            "servers": list(getattr(self.mcp_client, '_servers', {}).keys()),
+            "tools_count": mcp_tools_count,
+            "total_tools": len(self.tools)
+        }
+
+    def add_tool_dynamically(self, tool: BaseTool):
+        """
+        Add a tool to the bot's capabilities at runtime.
+        
+        This method allows dynamic tool addition after initialization, automatically
+        updating the model binding and workflow configuration.
+        
         Args:
-            history (List[BaseMessage]): Lista de mensajes a establecer
+            tool (BaseTool): The LangChain tool to add to the bot's capabilities
+            
+        Note:
+            Adding tools dynamically triggers a complete workflow reconstruction
+            to ensure proper tool integration and binding.
         """
-        self.chat_history = history.copy()
+        self.tools.append(tool)
+        # Reconstruct model binding and workflow with new tool
+        self.model_with_tools = self._prepare_model_with_tools()
+        self.instructions = self._build_modern_instructions()
+        self.graph = self._create_modern_workflow()
+
+    # ===== UTILITY AND DIAGNOSTIC METHODS =====
+
+    def get_workflow_state(self) -> Dict[str, Any]:
+        """
+        Get current workflow configuration for debugging and monitoring.
+        
+        Returns:
+            Dict[str, Any]: Workflow state information including:
+                - tools_count: Number of available tools
+                - has_checkpointer: Whether persistence is enabled
+                - has_vector_store: Whether file processing is active
+                - chat_history_length: Current conversation length
+        """
+        return {
+            "tools_count": len(self.tools),
+            "has_checkpointer": self.checkpointer is not None,
+            "has_vector_store": self.vector_store is not None,
+            "chat_history_length": len(self.chat_history),
+            "mcp_enabled": self.mcp_client is not None
+        }
+
+    def reset_conversation(self):
+        """
+        Reset conversation state while preserving configuration and processed files.
+        
+        This method clears only the conversation history while maintaining
+        tool configurations, file context, and other persistent settings.
+        """
+        self.chat_history.clear()
+
+    def get_tool_names(self) -> List[str]:
+        """
+        Get list of available tool names for diagnostic purposes.
+        
+        Returns:
+            List[str]: Names of all currently available tools
+        """
+        return [tool.name for tool in self.tools]
+
+    # ===== FIN DE LA CLASE =====
+    # No hay métodos legacy innecesarios
+
+

{sonika_langchain_bot-0.0.11.dist-info → sonika_langchain_bot-0.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonika-langchain-bot
-Version: 0.0.11
+Version: 0.0.12
 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.dist-info → sonika_langchain_bot-0.0.12.dist-info}/RECORD

@@ -1,14 +1,14 @@
 sonika_langchain_bot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sonika_langchain_bot/langchain_bdi.py,sha256=ithc55azP5XSPb8AGRUrDGYnVI6I4IqpqElLNat4BAQ,7024
-sonika_langchain_bot/langchain_bot_agent.py,sha256=z7jamAwZqQJEt7jWFZo2nMGWPS4dgTCghpKQdkR3BT4,10890
+sonika_langchain_bot/langchain_bot_agent.py,sha256=SBqiLWWTpSHi_v_pC6XelHyMpiSC-g2n1fGipZbgUQk,28631
 sonika_langchain_bot/langchain_bot_agent_bdi.py,sha256=Ev0hhRQYe6kyGAHiFDhFsfu6QnTwUFaA9oB8DfNV7u4,8613
 sonika_langchain_bot/langchain_clasificator.py,sha256=GR85ZAliymBSoDa5PXB31BvJkuiokGjS2v3RLdXnzzk,1381
 sonika_langchain_bot/langchain_class.py,sha256=5anB6v_wCzEoAJRb8fV9lPPS72E7-k51y_aeiip8RAw,1114
 sonika_langchain_bot/langchain_files.py,sha256=SEyqnJgBc_nbCIG31eypunBbO33T5AHFOhQZcghTks4,381
 sonika_langchain_bot/langchain_models.py,sha256=vqSSZ48tNofrTMLv1QugDdyey2MuIeSdlLSD37AnzkI,2235
 sonika_langchain_bot/langchain_tools.py,sha256=y7wLf1DbUua3QIvz938Ek-JIMOuQhrOIptJadW8OIsU,466
-sonika_langchain_bot-0.0.11.dist-info/licenses/LICENSE,sha256=O8VZ4aU_rUMAArvYTm2bshcZ991huv_tpfB5BKHH9Q8,1064
-sonika_langchain_bot-0.0.11.dist-info/METADATA,sha256=QBEkIYZbUqtflj8Lx-VBfTAY-3l6u4Mht0Dr1u1K3C8,6368
-sonika_langchain_bot-0.0.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sonika_langchain_bot-0.0.11.dist-info/top_level.txt,sha256=UsTTSZFEw2wrPSVh4ufu01e2m_E7O_QVYT_k4zCQaAE,21
-sonika_langchain_bot-0.0.11.dist-info/RECORD,,
+sonika_langchain_bot-0.0.12.dist-info/licenses/LICENSE,sha256=O8VZ4aU_rUMAArvYTm2bshcZ991huv_tpfB5BKHH9Q8,1064
+sonika_langchain_bot-0.0.12.dist-info/METADATA,sha256=hgBZ7RuN4683itsMD6gggfJrOtg-IrqV5tNbcIgnWb0,6380
+sonika_langchain_bot-0.0.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sonika_langchain_bot-0.0.12.dist-info/top_level.txt,sha256=UsTTSZFEw2wrPSVh4ufu01e2m_E7O_QVYT_k4zCQaAE,21
+sonika_langchain_bot-0.0.12.dist-info/RECORD,,