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

sonika_langchain_bot/langchain_bot_agent.py

@@ -1,10 +1,12 @@
-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
 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
@@ -24,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:
     """
@@ -38,6 +135,7 @@ 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
     """
 
@@ -47,9 +145,13 @@ class LangChainBot:
                  instructions: str, 
                  tools: Optional[List[BaseTool]] = None,
                  mcp_servers: Optional[Dict[str, Any]] = None,
-                 use_checkpointer: bool = False):
+                 use_checkpointer: bool = False,
+                 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
@@ -58,11 +160,36 @@ 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 (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())
+        
         # Core components
         self.language_model = language_model
         self.embeddings = embeddings
@@ -76,6 +203,11 @@ class LangChainBot:
         self.tools = tools or []
         self.mcp_client = None
         
+        # 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._initialize_mcp(mcp_servers)
@@ -121,9 +253,9 @@ class LangChainBot:
             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.logger.error(f"Error inicializando MCP: {e}")
+            self.logger.exception("Traceback completo:")
             self.mcp_client = None
 
     def _prepare_model_with_tools(self):
@@ -264,7 +396,8 @@ class LangChainBot:
                 }
                 
             except Exception as e:
-                print(f"Error in agent_node: {e}")
+                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 {
@@ -341,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
@@ -361,11 +495,18 @@ class LangChainBot:
             "context": ""
         }
         
-        # Execute the LangGraph workflow
-        #result = self.graph.invoke(initial_state)
-
-         # Siempre usar ainvoke (funciona para ambos casos)
-        result = asyncio.run(self.graph.ainvoke(initial_state))
+        # 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]
+        
+        # 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"]
@@ -398,7 +539,8 @@ class LangChainBot:
         Generate a streaming response for real-time user interaction.
         
         This method provides streaming capabilities while maintaining backward
-        compatibility with the original API.
+        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
@@ -415,10 +557,20 @@ class LangChainBot:
             "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 = ""
         
-        # Stream workflow execution
-        for chunk in self.graph.stream(initial_state):
+        # 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"]:
@@ -532,40 +684,6 @@ class LangChainBot:
         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])

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.15.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.15
+Version: 0.0.20
 Summary: Agente langchain con LLM
 Author: Erley Blanco Carvajal
 License: MIT License

{sonika_langchain_bot-0.0.15.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=LlzrINl543dPwizkQ-tW47OWzud0sP18Uwb-ZhxMHeA,23968
+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.15.dist-info/licenses/LICENSE,sha256=O8VZ4aU_rUMAArvYTm2bshcZ991huv_tpfB5BKHH9Q8,1064
-sonika_langchain_bot-0.0.15.dist-info/METADATA,sha256=TkIrUOf7OyjqybcPfdxsJkIAr_uKYPeh3cY1oVe8f4w,6508
-sonika_langchain_bot-0.0.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sonika_langchain_bot-0.0.15.dist-info/top_level.txt,sha256=UsTTSZFEw2wrPSVh4ufu01e2m_E7O_QVYT_k4zCQaAE,21
-sonika_langchain_bot-0.0.15.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,,