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

sonika_langchain_bot/langchain_bdi.py

@@ -64,16 +64,6 @@ class BotBeliefSystem:
     def _initialize_core_beliefs(self):
         """Initializes the core beliefs of the bot."""
         core_beliefs = [
-            Belief(
-                f"My name is {self.bot_name}.",
-                BeliefType.CORE,
-                confidence=1.0
-            ),
-            Belief(
-                f"I operate on Telegram, and my responses should be as concise and accurate as possible.",
-                BeliefType.CORE,
-                confidence=1.0
-            ),
             # Add more core beliefs as needed
         ]
         
@@ -81,6 +71,9 @@ class BotBeliefSystem:
             self.add_belief(belief)
 
     def add_tools_beliefs(self, tools: List[Tool]):
+
+        if len(tools) == 0:
+            return
         """Carga y procesa las herramientas disponibles para el bot."""
         # Instrucciones sobre el uso de herramientas en inglés
         instrucciones_de_uso = '''\nWhen you want to execute a tool, enclose the command with three asterisks and provide all parameters needed.

sonika_langchain_bot/langchain_bot_agent.py

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

sonika_langchain_bot/langchain_bot_agent_bdi.py

@@ -46,6 +46,7 @@ class LangChainBot:
         """
         beliefs_context = self.belief_system.generate_prompt_context()
         full_system_prompt = f"{beliefs_context}\n\n"
+        print(full_system_prompt)
 
         prompt = ChatPromptTemplate.from_messages([
             SystemMessagePromptTemplate.from_template(full_system_prompt),
@@ -94,6 +95,8 @@ class LangChainBot:
         if context:
             augmented_input = f"Context from attached files:\n{context}\n\nUser question: {user_input}"
 
+        print(augmented_input)
+
         bot_response = self.conversation.invoke({"input": augmented_input, "history": self.memory.chat_memory.messages})
 
         token_usage= bot_response.response_metadata['token_usage']

sonika_langchain_bot-0.0.11.dist-info/METADATA

@@ -0,0 +1,215 @@
+Metadata-Version: 2.4
+Name: sonika-langchain-bot
+Version: 0.0.11
+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==0.3.26
+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.11.dist-info/RECORD

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

{sonika_langchain_bot-0.0.9.dist-info → sonika_langchain_bot-0.0.11.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.9.dist-info/METADATA

@@ -1,145 +0,0 @@
-Metadata-Version: 2.1
-Name: sonika-langchain-bot
-Version: 0.0.9
-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.
-

sonika_langchain_bot-0.0.9.dist-info/RECORD

@@ -1,13 +0,0 @@
-sonika_langchain_bot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sonika_langchain_bot/langchain_bdi.py,sha256=aCo6d2vhn5d1xGmN3Ldpa8DStJUSLuhDPZ3y4iXILIg,7329
-sonika_langchain_bot/langchain_bot_agent_bdi.py,sha256=vYwhBznypQGn2rmwjHfkPFXzUSkhxslP9pGyymY3Nmo,8547
-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.9.dist-info/LICENSE,sha256=O8VZ4aU_rUMAArvYTm2bshcZ991huv_tpfB5BKHH9Q8,1064
-sonika_langchain_bot-0.0.9.dist-info/METADATA,sha256=SFXXWxpje_qXsvdLEr_4EgVg_eSOQjB7yH_5ayEIzqM,4454
-sonika_langchain_bot-0.0.9.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-sonika_langchain_bot-0.0.9.dist-info/top_level.txt,sha256=UsTTSZFEw2wrPSVh4ufu01e2m_E7O_QVYT_k4zCQaAE,21
-sonika_langchain_bot-0.0.9.dist-info/RECORD,,