sonika-langchain-bot 0.0.17__py3-none-any.whl → 0.0.20__py3-none-any.whl

sonika_langchain_bot/langchain_bot_agent.py

@@ -1,4 +1,4 @@
-from typing import Generator, List, Optional, Dict, Any, TypedDict, Annotated
+from typing import Generator, List, Optional, Dict, Any, TypedDict, Annotated, Callable
 import asyncio
 import logging
 from langchain.schema import AIMessage, HumanMessage, BaseMessage
@@ -6,6 +6,7 @@ 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 langchain.callbacks.base import BaseCallbackHandler
 from langgraph.graph import StateGraph, END, add_messages
 from langgraph.prebuilt import ToolNode
 from langgraph.checkpoint.memory import MemorySaver
@@ -25,6 +26,101 @@ class ChatState(TypedDict):
     messages: Annotated[List[BaseMessage], add_messages]
     context: str
 
+class _InternalToolLogger(BaseCallbackHandler):
+    """
+    Internal callback handler that bridges LangChain callbacks to user-provided functions.
+    
+    This class is used internally to forward tool execution events to the optional
+    callback functions provided by the user during bot initialization.
+    """
+    
+    def __init__(self, 
+                 on_start: Optional[Callable[[str, str], None]] = None,
+                 on_end: Optional[Callable[[str, str], None]] = None,
+                 on_error: Optional[Callable[[str, str], None]] = None):
+        """
+        Initialize the internal tool logger.
+        
+        Args:
+            on_start: Optional callback function called when a tool starts execution
+            on_end: Optional callback function called when a tool completes successfully
+            on_error: Optional callback function called when a tool encounters an error
+        """
+        super().__init__()
+        self.on_start_callback = on_start
+        self.on_end_callback = on_end
+        self.on_error_callback = on_error
+        self.current_tool_name = None
+        self.tool_executions = []  # Para tracking interno si se necesita
+    
+    def on_tool_start(self, serialized: Dict[str, Any], input_str: str, **kwargs) -> None:
+
+        print(f"DEBUG: on_tool_start se ejecutó!")  # ← AGREGAR ESTO
+
+
+        """Called when a tool starts executing."""
+        tool_name = serialized.get("name", "unknown")
+        self.current_tool_name = tool_name
+        
+        # Track execution internally
+        self.tool_executions.append({
+            "tool": tool_name,
+            "input": input_str,
+            "status": "started"
+        })
+        
+        # Call user's callback if provided
+        if self.on_start_callback:
+            try:
+                self.on_start_callback(tool_name, input_str)
+            except Exception as e:
+                # Don't let user callback errors break the workflow
+                logging.error(f"Error in on_tool_start callback: {e}")
+    
+    def on_tool_end(self, output: str, **kwargs) -> None:
+        print(f"DEBUG: on_tool_end se ejecutó!")
+        tool_name = self.current_tool_name or "unknown"
+        
+        # Convert output to string if it's a ToolMessage or other object
+        if hasattr(output, 'content'):
+            output_str = output.content
+        elif isinstance(output, str):
+            output_str = output
+        else:
+            output_str = str(output)
+        
+        # Update internal tracking
+        if self.tool_executions:
+            self.tool_executions[-1]["status"] = "success"
+            self.tool_executions[-1]["output"] = output_str
+        
+        # Call user's callback if provided
+        if self.on_end_callback:
+            try:
+                self.on_end_callback(tool_name, output_str)
+            except Exception as e:
+                logging.error(f"Error in on_tool_end callback: {e}")
+        
+        self.current_tool_name = None
+
+    def on_tool_error(self, error: Exception, **kwargs) -> None:  # ← CORRECTO
+        print(f"DEBUG: on_tool_error se ejecutó!")
+        tool_name = self.current_tool_name or "unknown"
+        error_message = str(error)
+        
+        # Update internal tracking
+        if self.tool_executions:
+            self.tool_executions[-1]["status"] = "error"
+            self.tool_executions[-1]["error"] = error_message
+        
+        # Call user's callback if provided
+        if self.on_error_callback:
+            try:
+                self.on_error_callback(tool_name, error_message)
+            except Exception as e:
+                logging.error(f"Error in on_tool_error callback: {e}")
+        
+        self.current_tool_name = None
 
 class LangChainBot:
     """
@@ -39,8 +135,8 @@ class LangChainBot:
         - File processing with vector search
         - Thread-based conversation persistence
         - Streaming responses
+        - Tool execution callbacks for real-time monitoring
         - Backward compatibility with legacy APIs
-        - Debug logging injection for production troubleshooting
     """
 
     def __init__(self, 
@@ -50,9 +146,12 @@ class LangChainBot:
                  tools: Optional[List[BaseTool]] = None,
                  mcp_servers: Optional[Dict[str, Any]] = None,
                  use_checkpointer: bool = False,
-                 logger: Optional[logging.Logger] = None):
+                 logger: Optional[logging.Logger] = None,
+                 on_tool_start: Optional[Callable[[str, str], None]] = None,
+                 on_tool_end: Optional[Callable[[str, str], None]] = None,
+                 on_tool_error: Optional[Callable[[str, str], None]] = None):
         """
-        Initialize the modern LangGraph bot with optional MCP support.
+        Initialize the modern LangGraph bot with optional MCP support and tool execution callbacks.
 
         Args:
             language_model (ILanguageModel): The language model to use for generation
@@ -61,28 +160,41 @@ class LangChainBot:
             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
-            logger (logging.Logger, optional): Logger instance for debugging. If None, uses silent NullHandler
+            logger (Optional[logging.Logger]): Logger instance for error tracking (silent by default if not provided)
+            on_tool_start (Callable[[str, str], None], optional): Callback function executed when a tool starts.
+                Receives (tool_name: str, input_data: str)
+            on_tool_end (Callable[[str, str], None], optional): Callback function executed when a tool completes successfully.
+                Receives (tool_name: str, output: str)
+            on_tool_error (Callable[[str, str], None], optional): Callback function executed when a tool fails.
+                Receives (tool_name: str, error_message: str)
         
         Note:
             The instructions will be automatically enhanced with tool descriptions
             when tools are provided, eliminating the need for manual tool instruction formatting.
+            
+        Example:
+```python
+            def on_tool_execution(tool_name: str, input_data: str):
+                print(f"Tool {tool_name} started with input: {input_data}")
+                
+            bot = LangChainBot(
+                language_model=model,
+                embeddings=embeddings,
+                instructions="You are a helpful assistant",
+                on_tool_start=on_tool_execution
+            )
+```
         """
         # Configure logger (silent by default if not provided)
         self.logger = logger or logging.getLogger(__name__)
         if logger is None:
             self.logger.addHandler(logging.NullHandler())
         
-        self.logger.info("="*80)
-        self.logger.info("🚀 Inicializando LangChainBot")
-        self.logger.info("="*80)
-        
         # Core components
         self.language_model = language_model
         self.embeddings = embeddings
         self.base_instructions = instructions
         
-        self.logger.debug(f"📋 Instrucciones base: {len(instructions)} caracteres")
-        
         # Backward compatibility attributes
         self.chat_history: List[BaseMessage] = []
         self.vector_store = None
@@ -91,39 +203,30 @@ class LangChainBot:
         self.tools = tools or []
         self.mcp_client = None
         
-        self.logger.info(f"🔧 Herramientas iniciales: {len(self.tools)}")
+        # Tool execution callbacks
+        self.on_tool_start = on_tool_start
+        self.on_tool_end = on_tool_end
+        self.on_tool_error = on_tool_error
         
         # Initialize MCP servers if provided
         if mcp_servers:
-            self.logger.info(f"🌐 Servidores MCP detectados: {len(mcp_servers)}")
             self._initialize_mcp(mcp_servers)
-        else:
-            self.logger.debug("⚪ Sin servidores MCP configurados")
         
         # Configure persistence layer
         self.checkpointer = MemorySaver() if use_checkpointer else None
-        self.logger.debug(f"💾 Checkpointer: {'Habilitado' if use_checkpointer else 'Deshabilitado'}")
         
         # Prepare model with bound tools for native function calling
-        self.logger.info("🤖 Preparando modelo con herramientas...")
         self.model_with_tools = self._prepare_model_with_tools()
         
         # Build modern instruction set with tool descriptions
-        self.logger.info("📝 Construyendo instrucciones modernas...")
         self.instructions = self._build_modern_instructions()
-        self.logger.debug(f"📋 Instrucciones finales: {len(self.instructions)} caracteres")
         
         # Create the LangGraph workflow
-        self.logger.info("🔄 Creando workflow de LangGraph...")
         self.graph = self._create_modern_workflow()
         
         # Legacy compatibility attributes (maintained for API compatibility)
         self.conversation = None
         self.agent_executor = None
-        
-        self.logger.info("✅ LangChainBot inicializado correctamente")
-        self.logger.info(f"📊 Resumen: {len(self.tools)} herramientas, {len(self.chat_history)} mensajes en historial")
-        self.logger.info("="*80 + "\n")
 
     def _initialize_mcp(self, mcp_servers: Dict[str, Any]):
         """
@@ -146,81 +249,14 @@ class LangChainBot:
             MCP tools are automatically appended to the existing tools list and
             will be included in the model's tool binding process.
         """
-        self.logger.info("="*80)
-        self.logger.info("🌐 INICIALIZANDO MCP (Model Context Protocol)")
-        self.logger.info("="*80)
-        
         try:
-            self.logger.info(f"📋 Servidores a inicializar: {len(mcp_servers)}")
-            
-            for server_name, server_config in mcp_servers.items():
-                self.logger.info(f"\n🔌 Servidor: {server_name}")
-                self.logger.debug(f"   Command: {server_config.get('command')}")
-                self.logger.debug(f"   Args: {server_config.get('args')}")
-                self.logger.debug(f"   Transport: {server_config.get('transport')}")
-            
-            self.logger.info("\n🔄 Creando MultiServerMCPClient...")
             self.mcp_client = MultiServerMCPClient(mcp_servers)
-            self.logger.info("✅ MultiServerMCPClient creado")
-            
-            # ===== FIX PARA APACHE/MOD_WSGI =====
-            self.logger.info("🔧 Aplicando fix para compatibilidad Apache/mod_wsgi...")
-            
-            import subprocess
-            original_create = asyncio.create_subprocess_exec
-            
-            async def fixed_create(*args, stdin=None, stdout=None, stderr=None, **kwargs):
-                """Forzar PIPE para evitar heredar sys.stderr de Apache"""
-                return await original_create(
-                    *args,
-                    stdin=stdin or subprocess.PIPE,
-                    stdout=stdout or subprocess.PIPE,
-                    stderr=stderr or subprocess.PIPE,
-                    **kwargs
-                )
-            
-            # Aplicar parche temporalmente
-            asyncio.create_subprocess_exec = fixed_create
-            self.logger.debug("✅ Parche temporal aplicado a asyncio.create_subprocess_exec")
-            
-            try:
-                self.logger.info("🔄 Obteniendo herramientas desde servidores MCP...")
-                mcp_tools = asyncio.run(self.mcp_client.get_tools())
-                self.logger.info(f"📥 Herramientas MCP recibidas: {len(mcp_tools)}")
-            finally:
-                # Restaurar original
-                asyncio.create_subprocess_exec = original_create
-                self.logger.debug("✅ Parche temporal removido, asyncio restaurado")
-            # =====================================
-            
-            if mcp_tools:
-                for i, tool in enumerate(mcp_tools, 1):
-                    tool_name = getattr(tool, 'name', 'Unknown')
-                    tool_desc = getattr(tool, 'description', 'Sin descripción')
-                    self.logger.debug(f"   {i}. {tool_name}: {tool_desc[:100]}...")
-            
+            mcp_tools = asyncio.run(self.mcp_client.get_tools())
             self.tools.extend(mcp_tools)
-            
-            self.logger.info(f"✅ MCP inicializado exitosamente")
-            self.logger.info(f"📊 Total herramientas disponibles: {len(self.tools)}")
-            self.logger.info(f"   - Herramientas MCP: {len(mcp_tools)}")
-            self.logger.info(f"   - Herramientas previas: {len(self.tools) - len(mcp_tools)}")
-            self.logger.info("="*80 + "\n")
-            
         except Exception as e:
-            self.logger.error("="*80)
-            self.logger.error("❌ ERROR EN INICIALIZACIÓN MCP")
-            self.logger.error("="*80)
-            self.logger.error(f"Tipo de error: {type(e).__name__}")
-            self.logger.error(f"Mensaje: {str(e)}")
+            self.logger.error(f"Error inicializando MCP: {e}")
             self.logger.exception("Traceback completo:")
-            self.logger.error("="*80 + "\n")
-            
             self.mcp_client = None
-            
-            # Mensaje de diagnóstico
-            self.logger.warning("⚠️ Continuando sin MCP - solo herramientas locales disponibles")
-            self.logger.warning(f"   Herramientas disponibles: {len(self.tools)}")
 
     def _prepare_model_with_tools(self):
         """
@@ -233,31 +269,13 @@ class LangChainBot:
             The language model with tools bound, or the original model if no tools are available
         """
         if self.tools:
-            self.logger.info(f"🔗 Vinculando {len(self.tools)} herramientas al modelo")
-            try:
-                bound_model = self.language_model.model.bind_tools(self.tools)
-                self.logger.info("✅ Herramientas vinculadas correctamente")
-                return bound_model
-            except Exception as e:
-                self.logger.error(f"❌ Error vinculando herramientas: {e}")
-                self.logger.exception("Traceback:")
-                return self.language_model.model
-        else:
-            self.logger.debug("⚪ Sin herramientas para vincular, usando modelo base")
-            return self.language_model.model
+            return self.language_model.model.bind_tools(self.tools)
+        return self.language_model.model
 
     def _build_modern_instructions(self) -> str:
-        """
-        Build modern instructions with automatic tool documentation.
-        
-        Returns:
-            str: Enhanced instructions with tool descriptions
-        """
         instructions = self.base_instructions
         
         if self.tools:
-            self.logger.info(f"📝 Generando documentación para {len(self.tools)} herramientas")
-            
             tools_description = "\n\n# Available Tools\n\n"
             
             for tool in self.tools:
@@ -271,7 +289,7 @@ class LangChainBot:
                         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: args_schema es un dict (MCP Tools)
+                # Opción 2: args_schema es un dict (MCP Tools) ← NUEVO
                 elif hasattr(tool, 'args_schema') and isinstance(tool.args_schema, dict):
                     if 'properties' in tool.args_schema:
                         tools_description += f"**Parameters:**\n"
@@ -301,7 +319,6 @@ class LangChainBot:
                                 "- Do NOT call tools with empty arguments\n")
             
             instructions += tools_description
-            self.logger.info(f"✅ Documentación de herramientas agregada ({len(tools_description)} caracteres)")
         
         return instructions
 
@@ -318,14 +335,24 @@ class LangChainBot:
         Returns:
             StateGraph: Compiled LangGraph workflow ready for execution
         """
-        self.logger.info("🔄 Construyendo workflow de LangGraph")
         
         def agent_node(state: ChatState) -> ChatState:
             """
             Main agent node responsible for generating responses and initiating tool calls.
-            """
-            self.logger.debug("🤖 Ejecutando agent_node")
             
+            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"]):
@@ -334,15 +361,10 @@ class LangChainBot:
                     break
             
             if not last_user_message:
-                self.logger.warning("⚠️ No se encontró mensaje de usuario")
                 return state
             
-            self.logger.debug(f"💬 Mensaje usuario: {last_user_message[:100]}...")
-            
             # Retrieve contextual information from processed files
             context = self._get_context(last_user_message)
-            if context:
-                self.logger.debug(f"📚 Contexto recuperado: {len(context)} caracteres")
             
             # Build system prompt with optional context
             system_content = self.instructions
@@ -359,33 +381,24 @@ class LangChainBot:
                 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}"})
             
-            self.logger.debug(f"📨 Enviando {len(messages)} mensajes al modelo")
-            
             try:
                 # Invoke model with native tool binding
                 response = self.model_with_tools.invoke(messages)
                 
-                self.logger.debug(f"✅ Respuesta recibida del modelo")
-                
-                # Check for tool calls
-                if hasattr(response, 'tool_calls') and response.tool_calls:
-                    self.logger.info(f"🔧 Llamadas a herramientas detectadas: {len(response.tool_calls)}")
-                    for i, tc in enumerate(response.tool_calls, 1):
-                        tool_name = tc.get('name', 'Unknown')
-                        self.logger.debug(f"   {i}. {tool_name}")
-                
                 # Return updated state
                 return {
                     **state,
                     "context": context,
-                    "messages": [response]
+                    "messages": [response]  # add_messages annotation handles proper appending
                 }
                 
             except Exception as e:
-                self.logger.error(f"❌ Error en agent_node: {e}")
-                self.logger.exception("Traceback:")
+                self.logger.error(f"Error en agent_node: {e}")
+                self.logger.exception("Traceback completo:")
+                # Graceful fallback for error scenarios
                 fallback_response = AIMessage(content="I apologize, but I encountered an error processing your request.")
                 return {
                     **state,
@@ -396,16 +409,24 @@ class LangChainBot:
         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):
-                self.logger.debug("➡️ Continuando a ejecución de herramientas")
                 return "tools"
             
-            self.logger.debug("🏁 Finalizando workflow")
             return "end"
 
         # Construct the workflow graph
@@ -413,18 +434,18 @@ class LangChainBot:
         
         # Add primary agent node
         workflow.add_node("agent", agent_node)
-        self.logger.debug("✅ Nodo 'agent' agregado")
         
         # 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)
-            self.logger.debug("✅ Nodo 'tools' agregado")
         
         # 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,
@@ -433,21 +454,17 @@ class LangChainBot:
                     "end": END
                 }
             )
+            # Return to agent after tool execution for final response formatting
             workflow.add_edge("tools", "agent")
-            self.logger.debug("✅ Edges condicionales configurados")
         else:
+            # Direct termination if no tools are available
             workflow.add_edge("agent", END)
-            self.logger.debug("✅ Edge directo a END configurado")
         
         # Compile workflow with optional checkpointing
         if self.checkpointer:
-            compiled = workflow.compile(checkpointer=self.checkpointer)
-            self.logger.info("✅ Workflow compilado con checkpointer")
+            return workflow.compile(checkpointer=self.checkpointer)
         else:
-            compiled = workflow.compile()
-            self.logger.info("✅ Workflow compilado sin checkpointer")
-        
-        return compiled
+            return workflow.compile()
 
     # ===== LEGACY API COMPATIBILITY =====
     
@@ -457,6 +474,7 @@ class LangChainBot:
         
         This method provides the primary interface for single-turn conversations,
         maintaining backward compatibility with existing ChatService implementations.
+        Tool execution callbacks (if provided) will be triggered during execution.
         
         Args:
             user_input (str): The user's message or query
@@ -471,176 +489,202 @@ class LangChainBot:
             This method automatically handles tool execution and context integration
             from processed files while maintaining the original API signature.
         """
-        self.logger.info("="*80)
-        self.logger.info("📨 GET_RESPONSE llamado")
-        self.logger.debug(f"💬 Input: {user_input[:200]}...")
-        
         # Prepare initial workflow state
         initial_state = {
             "messages": self.chat_history + [HumanMessage(content=user_input)],
             "context": ""
         }
         
-        self.logger.debug(f"📊 Estado inicial: {len(initial_state['messages'])} mensajes")
-        
-        try:
-            # Execute the LangGraph workflow
-            self.logger.info("🔄 Ejecutando workflow...")
-            result = asyncio.run(self.graph.ainvoke(initial_state))
-            self.logger.info("✅ Workflow completado")
-            
-            # Update internal conversation history
-            self.chat_history = result["messages"]
-            self.logger.debug(f"💾 Historial actualizado: {len(self.chat_history)} mensajes")
-            
-            # 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)
-            
-            self.logger.info(f"📊 Tokens: input={total_input_tokens}, output={total_output_tokens}")
-            self.logger.info(f"📝 Respuesta: {len(final_response)} caracteres")
-            self.logger.info("="*80 + "\n")
-            
-            return ResponseModel(
-                user_tokens=total_input_tokens,
-                bot_tokens=total_output_tokens,
-                response=final_response
+        # Create callback handler if any callbacks are provided
+        config = {}
+        if self.on_tool_start or self.on_tool_end or self.on_tool_error:
+            tool_logger = _InternalToolLogger(
+                on_start=self.on_tool_start,
+                on_end=self.on_tool_end,
+                on_error=self.on_tool_error
             )
-            
-        except Exception as e:
-            self.logger.error("="*80)
-            self.logger.error("❌ ERROR EN GET_RESPONSE")
-            self.logger.error(f"Mensaje: {str(e)}")
-            self.logger.exception("Traceback:")
-            self.logger.error("="*80 + "\n")
-            raise
+            config["callbacks"] = [tool_logger]
+        
+        # Execute the LangGraph workflow with callbacks
+        result = asyncio.run(self.graph.ainvoke(initial_state, config=config))
+        
+        # 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.
-        """
-        self.logger.info("📨 GET_RESPONSE_STREAM llamado")
-        self.logger.debug(f"💬 Input: {user_input[:200]}...")
         
+        This method provides streaming capabilities while maintaining backward
+        compatibility with the original API. Tool execution callbacks (if provided)
+        will be triggered during execution.
+        
+        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": ""
         }
         
+        # Create callback handler if any callbacks are provided
+        config = {}
+        if self.on_tool_start or self.on_tool_end or self.on_tool_error:
+            tool_logger = _InternalToolLogger(
+                on_start=self.on_tool_start,
+                on_end=self.on_tool_end,
+                on_error=self.on_tool_error
+            )
+            config["callbacks"] = [tool_logger]
+        
         accumulated_response = ""
         
-        try:
-            for chunk in self.graph.stream(initial_state):
-                if "agent" in chunk:
-                    for message in chunk["agent"]["messages"]:
-                        if isinstance(message, AIMessage) and message.content:
-                            accumulated_response = message.content
-                            yield message.content
-            
-            if accumulated_response:
-                self.chat_history.extend([
-                    HumanMessage(content=user_input),
-                    AIMessage(content=accumulated_response)
-                ])
-                
-            self.logger.info(f"✅ Stream completado: {len(accumulated_response)} caracteres")
-            
-        except Exception as e:
-            self.logger.error(f"❌ Error en stream: {e}")
-            self.logger.exception("Traceback:")
-            raise
+        # Stream workflow execution with callbacks
+        for chunk in self.graph.stream(initial_state, config=config):
+            # 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.logger.info(f"📥 Cargando historial: {len(messages)} mensajes")
         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))
-        self.logger.debug("✅ Historial cargado")
 
     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.logger.debug("💾 Guardando mensajes en historial interno")
         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.
-        """
-        self.logger.info("📄 Procesando archivo para indexación")
-        try:
-            document = file.getText()
-            text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
-            texts = text_splitter.split_documents(document)
+        
+        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()
             
-            self.logger.debug(f"✂️ Documento dividido en {len(texts)} chunks")
+        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.logger.info("✅ Vector store creado")
-            else:
-                self.vector_store.add_texts([doc.page_content for doc in texts])
-                self.logger.info("✅ Textos agregados a vector store existente")
-                
-        except Exception as e:
-            self.logger.error(f"❌ Error procesando archivo: {e}")
-            self.logger.exception("Traceback:")
-            raise
+        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.logger.info("🗑️ Limpiando memoria")
         self.chat_history.clear()
         self.vector_store = None
-        self.logger.debug("✅ Memoria limpiada")
 
     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.logger.info(f"📝 Estableciendo historial: {len(history)} mensajes")
         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:
-            self.logger.debug(f"🔍 Buscando contexto para query: {query[:100]}...")
             docs = self.vector_store.similarity_search(query, k=4)
-            context = "\n".join([doc.page_content for doc in docs])
-            self.logger.debug(f"✅ Contexto encontrado: {len(context)} caracteres")
-            return context
+            return "\n".join([doc.page_content for doc in docs])
         return ""

sonika_langchain_bot/langchain_clasificator.py

@@ -2,16 +2,30 @@ from pydantic import BaseModel
 from typing import Dict, Any, Type
 from sonika_langchain_bot.langchain_class import ILanguageModel
 
-# Clase para realizar la clasificación de texto
+class ClassificationResponse(BaseModel):
+    """Respuesta de clasificación con tokens utilizados"""
+    input_tokens: int
+    output_tokens: int
+    result: Dict[str, Any]
+
 class TextClassifier:
     def __init__(self, validation_class: Type[BaseModel], llm: ILanguageModel):
-        self.llm =llm
+        self.llm = llm
         self.validation_class = validation_class
-        #configuramos el modelo para que tenga una estructura de salida
-        self.llm.model =  self.llm.model.with_structured_output(validation_class)
+        # Guardamos ambas versiones del modelo
+        self.original_model = self.llm.model  # Sin structured output
+        self.structured_model = self.llm.model.with_structured_output(validation_class)
 
-    def classify(self, text: str) -> Dict[str, Any]:
-        # Crear el template del prompt
+    def classify(self, text: str) -> ClassificationResponse:
+        """
+        Clasifica el texto según la clase de validación.
+        
+        Args:
+            text: Texto a clasificar
+        
+        Returns:
+            ClassificationResponse: Objeto con result, input_tokens y output_tokens
+        """
         prompt = f"""
         Classify the following text based on the properties defined in the validation class.
         
@@ -19,12 +33,34 @@ class TextClassifier:
         
         Only extract the properties mentioned in the validation class.
         """
-        response = self.llm.invoke(prompt=prompt)
         
-        # Asegurarse de que el `response` es de la clase de validación proporcionada
+        # Primero invocamos el modelo ORIGINAL para obtener metadata de tokens
+        raw_response = self.original_model.invoke(prompt)
+        
+        # Extraer información de tokens del AIMessage original
+        input_tokens = 0
+        output_tokens = 0
+        
+        if hasattr(raw_response, 'response_metadata'):
+            token_usage = raw_response.response_metadata.get('token_usage', {})
+            input_tokens = token_usage.get('prompt_tokens', 0)
+            output_tokens = token_usage.get('completion_tokens', 0)
+        
+        # Ahora invocamos con structured output para obtener el objeto parseado
+        response = self.structured_model.invoke(prompt)
+        
+        # Validar que el response es de la clase correcta
         if isinstance(response, self.validation_class):
-            # Crear el resultado dinámicamente basado en los atributos de la clase de validación
-            result = {field: getattr(response, field) for field in self.validation_class.__fields__.keys()}
-            return result
+            # Crear el resultado dinámicamente basado en los atributos
+            result_data = {
+                field: getattr(response, field) 
+                for field in self.validation_class.__fields__.keys()
+            }
+            
+            return ClassificationResponse(
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                result=result_data
+            )
         else:
-            raise ValueError(f"The response is not of type '{self.validation_class.__name__}'")
+            raise ValueError(f"The response is not of type '{self.validation_class.__name__}'")

{sonika_langchain_bot-0.0.17.dist-info → sonika_langchain_bot-0.0.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonika-langchain-bot
-Version: 0.0.17
+Version: 0.0.20
 Summary: Agente langchain con LLM
 Author: Erley Blanco Carvajal
 License: MIT License

{sonika_langchain_bot-0.0.17.dist-info → sonika_langchain_bot-0.0.20.dist-info}/RECORD

@@ -1,15 +1,15 @@
 sonika_langchain_bot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sonika_langchain_bot/document_processor.py,sha256=RuHT22Zt-psoe4adFWKwBJ0gi638fq8r2S5WZoDK8fY,10979
 sonika_langchain_bot/langchain_bdi.py,sha256=ithc55azP5XSPb8AGRUrDGYnVI6I4IqpqElLNat4BAQ,7024
-sonika_langchain_bot/langchain_bot_agent.py,sha256=UXcLkyVisyrDXfikKVYj-8l3FvGS8WJUT_G6XpPZO_w,28955
+sonika_langchain_bot/langchain_bot_agent.py,sha256=l1Kj4iDnGSH-1NZkFxdlVCKOQxoDMsPjWNdxS3GapcA,29214
 sonika_langchain_bot/langchain_bot_agent_bdi.py,sha256=Ev0hhRQYe6kyGAHiFDhFsfu6QnTwUFaA9oB8DfNV7u4,8613
-sonika_langchain_bot/langchain_clasificator.py,sha256=GR85ZAliymBSoDa5PXB31BvJkuiokGjS2v3RLdXnzzk,1381
+sonika_langchain_bot/langchain_clasificator.py,sha256=h0-H_1bqgA04rF2ZHh5zOg2PinqTuLQMcSK7AGK4uw8,2583
 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.17.dist-info/licenses/LICENSE,sha256=O8VZ4aU_rUMAArvYTm2bshcZ991huv_tpfB5BKHH9Q8,1064
-sonika_langchain_bot-0.0.17.dist-info/METADATA,sha256=q7AL7tRyc9_WhSL4bI_h0QWre1YV4qL3sQTI6v2ovd4,6508
-sonika_langchain_bot-0.0.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sonika_langchain_bot-0.0.17.dist-info/top_level.txt,sha256=UsTTSZFEw2wrPSVh4ufu01e2m_E7O_QVYT_k4zCQaAE,21
-sonika_langchain_bot-0.0.17.dist-info/RECORD,,
+sonika_langchain_bot-0.0.20.dist-info/licenses/LICENSE,sha256=O8VZ4aU_rUMAArvYTm2bshcZ991huv_tpfB5BKHH9Q8,1064
+sonika_langchain_bot-0.0.20.dist-info/METADATA,sha256=bIPx5NtqGhSIRI1nPP-PZInj8MUhHRheq7VRwQNqOXY,6508
+sonika_langchain_bot-0.0.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sonika_langchain_bot-0.0.20.dist-info/top_level.txt,sha256=UsTTSZFEw2wrPSVh4ufu01e2m_E7O_QVYT_k4zCQaAE,21
+sonika_langchain_bot-0.0.20.dist-info/RECORD,,