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

sonika_langchain_bot/langchain_bot_agent.py

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

@@ -0,0 +1,215 @@
+Metadata-Version: 2.4
+Name: sonika-langchain-bot
+Version: 0.0.12
+Summary: Agente langchain con LLM
+Author: Erley Blanco Carvajal
+License: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+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
+Requires-Dist: langgraph==0.4.8
+Requires-Dist: langgraph-checkpoint==2.1.0
+Requires-Dist: langgraph-sdk==0.1.70
+Requires-Dist: dataclasses-json==0.6.7
+Requires-Dist: python-dateutil==2.9.0.post0
+Requires-Dist: pydantic==2.11.7
+Requires-Dist: faiss-cpu==1.11.0
+Requires-Dist: pypdf==5.6.1
+Requires-Dist: python-dotenv==1.0.1
+Requires-Dist: typing_extensions==4.14.0
+Requires-Dist: typing-inspect==0.9.0
+Provides-Extra: dev
+Requires-Dist: sphinx<9.0.0,>=8.1.3; extra == "dev"
+Requires-Dist: sphinx-rtd-theme<4.0.0,>=3.0.1; extra == "dev"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Sonika LangChain Bot <a href="https://pepy.tech/projects/sonika-langchain-bot"><img src="https://static.pepy.tech/badge/sonika-langchain-bot" alt="PyPI Downloads"></a>
+
+A Python library that implements a conversational agent using LangChain with tool execution capabilities and text classification.
+
+## Installation
+
+```bash
+pip install sonika-langchain-bot
+```
+
+## Prerequisites
+
+You'll need the following API keys:
+
+- OpenAI API Key
+
+Create a `.env` file in the root of your project with the following variables:
+
+```env
+OPENAI_API_KEY=your_api_key_here
+```
+
+## Key Features
+
+- Conversational agent with tool execution capabilities
+- Text classification with structured output
+- Custom tool integration
+- Streaming responses
+- Conversation history management
+- Flexible instruction-based behavior
+
+## Basic Usage
+
+### Agent with Tools Example
+
+```python
+import os
+from dotenv import load_dotenv
+from langchain_openai import OpenAIEmbeddings
+from sonika_langchain_bot.langchain_tools import EmailTool
+from sonika_langchain_bot.langchain_bot_agent import LangChainBot
+from sonika_langchain_bot.langchain_class import Message, ResponseModel
+from sonika_langchain_bot.langchain_models import OpenAILanguageModel
+
+# Load environment variables
+load_dotenv()
+
+# Get API key from .env file
+api_key = os.getenv("OPENAI_API_KEY")
+
+# Initialize language model and embeddings
+language_model = OpenAILanguageModel(api_key, model_name='gpt-4o-mini-2024-07-18', temperature=1)
+embeddings = OpenAIEmbeddings(api_key=api_key)
+
+# Configure tools
+tools = [EmailTool()]
+
+# Create agent instance
+bot = LangChainBot(language_model, embeddings, instructions="You are an agent", tools=tools)
+
+# Load conversation history
+bot.load_conversation_history([Message(content="My name is Erley", is_bot=False)])
+
+# Get response
+user_message = 'Send an email with the tool to erley@gmail.com with subject Hello and message Hello Erley'
+response_model: ResponseModel = bot.get_response(user_message)
+
+print(response_model)
+```
+
+### Streaming Response Example
+
+```python
+import os
+from dotenv import load_dotenv
+from langchain_openai import OpenAIEmbeddings
+from sonika_langchain_bot.langchain_bot_agent import LangChainBot
+from sonika_langchain_bot.langchain_class import Message
+from sonika_langchain_bot.langchain_models import OpenAILanguageModel
+
+# Load environment variables
+load_dotenv()
+
+# Get API key from .env file
+api_key = os.getenv("OPENAI_API_KEY")
+
+# Initialize language model and embeddings
+language_model = OpenAILanguageModel(api_key, model_name='gpt-4o-mini-2024-07-18', temperature=1)
+embeddings = OpenAIEmbeddings(api_key=api_key)
+
+# Create agent instance
+bot = LangChainBot(language_model, embeddings, instructions="Only answers in english", tools=[])
+
+# Load conversation history
+bot.load_conversation_history([Message(content="My name is Erley", is_bot=False)])
+
+# Get streaming response
+user_message = 'Hello, what is my name?'
+for chunk in bot.get_response_stream(user_message):
+    print(chunk)
+```
+
+### Text Classification Example
+
+```python
+import os
+from dotenv import load_dotenv
+from sonika_langchain_bot.langchain_clasificator import TextClassifier
+from sonika_langchain_bot.langchain_models import OpenAILanguageModel
+from pydantic import BaseModel, Field
+
+# Load environment variables
+load_dotenv()
+
+# Define classification structure with Pydantic
+class Classification(BaseModel):
+    intention: str = Field()
+    sentiment: str = Field(..., enum=["happy", "neutral", "sad", "excited"])
+    aggressiveness: int = Field(
+        ...,
+        description="describes how aggressive the statement is, the higher the number the more aggressive",
+        enum=[1, 2, 3, 4, 5],
+    )
+    language: str = Field(
+        ..., enum=["spanish", "english", "french", "german", "italian"]
+    )
+
+# Initialize classifier
+api_key = os.getenv("OPENAI_API_KEY")
+model = OpenAILanguageModel(api_key=api_key)
+classifier = TextClassifier(llm=model, validation_class=Classification)
+
+# Classify text
+result = classifier.classify("how are you?")
+print(result)
+```
+
+## Available Classes and Components
+
+### Core Classes
+
+- **LangChainBot**: Main conversational agent for task execution with tools
+- **OpenAILanguageModel**: Wrapper for OpenAI language models
+- **TextClassifier**: Text classification using structured output
+- **Message**: Message structure for conversation history
+- **ResponseModel**: Response structure from agent interactions
+
+### Tools
+
+- **EmailTool**: Tool for sending emails through the agent
+
+## Project Structure
+
+```
+your_project/
+├── .env                    # Environment variables
+├── src/
+│   └── sonika_langchain_bot/
+│       ├── langchain_bot_agent.py
+│       ├── langchain_clasificator.py
+│       ├── langchain_class.py
+│       ├── langchain_models.py
+│       └── langchain_tools.py
+└── tests/
+    └── test_bot.py
+```
+
+## Contributing
+
+Contributions are welcome. Please open an issue to discuss major changes you'd like to make.
+
+## License
+
+This project is licensed under the MIT License.

{sonika_langchain_bot-0.0.10.dist-info → sonika_langchain_bot-0.0.12.dist-info}/RECORD

@@ -1,13 +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=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.10.dist-info/LICENSE,sha256=O8VZ4aU_rUMAArvYTm2bshcZ991huv_tpfB5BKHH9Q8,1064
-sonika_langchain_bot-0.0.10.dist-info/METADATA,sha256=UFs95OjxiI17n839Ylb2ou-eR8sJ11MrMu7V3TOa0sA,4455
-sonika_langchain_bot-0.0.10.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-sonika_langchain_bot-0.0.10.dist-info/top_level.txt,sha256=UsTTSZFEw2wrPSVh4ufu01e2m_E7O_QVYT_k4zCQaAE,21
-sonika_langchain_bot-0.0.10.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,,

{sonika_langchain_bot-0.0.10.dist-info → sonika_langchain_bot-0.0.12.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.5.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

sonika_langchain_bot-0.0.10.dist-info/METADATA

@@ -1,145 +0,0 @@
-Metadata-Version: 2.1
-Name: sonika-langchain-bot
-Version: 0.0.10
-Summary: Agente langchain con LLM
-Author: Erley Blanco Carvajal
-License: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: langchain <1.0.0,>=0.3.0
-Requires-Dist: langchain-community <1.0.0,>=0.3.0
-Requires-Dist: langchain-core <1.0.0,>=0.3.5
-Requires-Dist: langchain-openai <1.0.0,>=0.2.0
-Requires-Dist: langgraph <1.0.0,>=0.2.39
-Requires-Dist: langgraph-checkpoint <3.0.0,>=2.0.2
-Requires-Dist: langgraph-sdk <2.0.0,>=0.1.34
-Requires-Dist: dataclasses-json <1.0.0,>=0.6.7
-Requires-Dist: python-dateutil <3.0.0,>=2.9.0
-Requires-Dist: tiktoken <1.0.0,>=0.7.0
-Requires-Dist: pydantic <3.0.0,>=2.9.2
-Requires-Dist: faiss-cpu <2.0.0,>=1.8.0
-Requires-Dist: pypdf <6.0.0,>=5.0.0
-Requires-Dist: python-dotenv <2.0.0,>=1.0.1
-Requires-Dist: typing-extensions <5.0.0,>=4.12.0
-Requires-Dist: typing-inspect <1.0.0,>=0.9.0
-Provides-Extra: dev
-Requires-Dist: sphinx <9.0.0,>=8.1.3 ; extra == 'dev'
-Requires-Dist: sphinx-rtd-theme <4.0.0,>=3.0.1 ; extra == 'dev'
-
-# Sonika LangChain Bot <a href="https://pepy.tech/projects/sonika-langchain-bot"><img src="https://static.pepy.tech/badge/sonika-langchain-bot" alt="PyPI Downloads"></a>
-
-
-Una librería Python que implementa un bot conversacional utilizando LangChain con capacidades BDI (Belief-Desire-Intention) y clasificación de texto.
-
-## Instalación
-
-```bash
-pip install sonika-langchain-bot
-```
-
-## Requisitos previos
-
-Necesitarás las siguientes API keys:
-
-- OpenAI API Key
-
-Crea un archivo `.env` en la raíz de tu proyecto con las siguientes variables:
-
-```env
-OPENAI_API_KEY=tu_api_key_aqui
-```
-
-## Características principales
-
-- Bot conversacional con arquitectura BDI
-- Clasificación de texto
-- Ejecución de código personalizado por medio de tools
-
-## Uso básico
-
-### Ejemplo de Bot BDI
-
-```python
-from sonika_langchain_bot.langchain_bdi import Belief, BeliefType
-from sonika_langchain_bot.langchain_bot_agent_bdi import LangChainBot
-from sonika_langchain_bot.langchain_models import OpenAILanguageModel
-from langchain_openai import OpenAIEmbeddings
-
-# Inicializar el modelo de lenguaje
-language_model = OpenAILanguageModel(api_key, model_name='gpt-4o-mini', temperature=1)
-embeddings = OpenAIEmbeddings(api_key=api_key)
-
-# Configurar herramientas propias o de terceros
-search = TavilySearchResults(max_results=2, api_key=api_key_tavily)
-tools = [search]
-
-# Configurar creencias
-beliefs = [
-    Belief(
-        content="Eres un asistente de chat",
-        type=BeliefType.PERSONALITY,
-        confidence=1,
-        source='personality'
-    )
-]
-
-# Crear instancia del bot
-bot = LangChainBot(language_model, embeddings, beliefs=beliefs, tools=tools)
-
-# Obtener respuesta
-response = bot.get_response("Hola como te llamas?")
-
-bot = LangChainBot(language_model, embeddings, beliefs=beliefs, tools=tools)
-
-user_message = 'Hola como me llamo?'
-
-#Cargas la conversacion previa con el bot
-bot.load_conversation_history([Message(content="Mi nombre es Erley", is_bot=False)])
-# Obtener la respuesta del bot
-response_model: ResponseModel = bot.get_response(user_message)
-bot_response = response_model
-
-print(bot_response)
-
-#o por streaming
-for chunk in bot.get_response_stream(user_message):
-    print(chunk)
-
-```
-
-### Ejemplo de Clasificación de Texto
-
-```python
-from sonika_langchain_bot.langchain_clasificator import TextClassifier
-from sonika_langchain_bot.langchain_models import OpenAILanguageModel
-from pydantic import BaseModel, Field
-
-# Definir estructura de clasificación
-class Classification(BaseModel):
-    intention: str = Field()
-    sentiment: str = Field(..., enum=["feliz", "neutral", "triste", "excitado"])
-    aggressiveness: int = Field(
-        ...,
-        description="describes how aggressive the statement is",
-        enum=[1, 2, 3, 4, 5],
-    )
-    language: str = Field(
-        ..., enum=["español", "ingles", "frances", "aleman", "italiano"]
-    )
-
-# Inicializar clasificador
-model = OpenAILanguageModel(api_key=api_key)
-classifier = TextClassifier(llm=model, validation_class=Classification)
-
-# Clasificar texto
-result = classifier.classify("Tu texto aquí")
-```
-
-## Contribución
-
-Las contribuciones son bienvenidas. Por favor, abre un issue para discutir los cambios importantes que te gustaría hacer.
-