sonika-langchain-bot 0.0.10__tar.gz → 0.0.11__tar.gz

sonika_langchain_bot-0.0.11/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,174 @@
+# 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 → sonika_langchain_bot-0.0.11}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="sonika-langchain-bot",
-    version="0.0.10", 
+    version="0.0.11", 
     description="Agente langchain con LLM",
     author="Erley Blanco Carvajal",
     license="MIT License",
@@ -11,23 +11,23 @@ setup(
     packages=find_packages(where="src"),  # Encuentra los paquetes dentro de "src"
     package_dir={"": "src"},  # Indica que los paquetes están en el directorio "src"
     install_requires=[
-        "langchain>=0.3.0,<1.0.0",  # Permite mayor flexibilidad
-        "langchain-community>=0.3.0,<1.0.0",
-        "langchain-core>=0.3.5,<1.0.0",
-        "langchain-openai>=0.2.0,<1.0.0",
-        "langgraph>=0.2.39,<1.0.0",
-        "langgraph-checkpoint>=2.0.2,<3.0.0",
-        "langgraph-sdk>=0.1.34,<2.0.0",
-        "dataclasses-json>=0.6.7,<1.0.0",
-        "python-dateutil>=2.9.0,<3.0.0",
-        "tiktoken>=0.7.0,<1.0.0",
-        "pydantic>=2.9.2,<3.0.0",
-        "faiss-cpu>=1.8.0,<2.0.0",
-        "pypdf>=5.0.0,<6.0.0",
-        "python-dotenv>=1.0.1,<2.0.0",
-        "typing_extensions>=4.12.0,<5.0.0",
-        "typing-inspect>=0.9.0,<1.0.0",
+        "langchain==0.3.26",
+        "langchain-community==0.3.26",
+        "langchain-core==0.3.66",
+        "langchain-openai==0.3.24",
+        "langgraph==0.4.8",
+        "langgraph-checkpoint==2.1.0",
+        "langgraph-sdk==0.1.70",
+        "dataclasses-json==0.6.7",
+        "python-dateutil==2.9.0.post0",
+        "pydantic==2.11.7",
+        "faiss-cpu==1.11.0",
+        "pypdf==5.6.1",
+        "python-dotenv==1.0.1",
+        "typing_extensions==4.14.0",
+        "typing-inspect==0.9.0",
     ],
+
     extras_require={
         "dev": [
             "sphinx>=8.1.3,<9.0.0",

sonika_langchain_bot-0.0.10/src/sonika_langchain_bot/langchain_bot_agent_bdi.py → sonika_langchain_bot-0.0.11/src/sonika_langchain_bot/langchain_bot_agent.py

@@ -1,11 +1,8 @@
-from typing import Generator
-from typing import List
-from langchain.memory import ConversationBufferMemory
+from typing import Generator, List
 from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, HumanMessagePromptTemplate
-from langchain.schema import AIMessage, HumanMessage
+from langchain.schema import AIMessage, HumanMessage, BaseMessage
 from langchain.text_splitter import CharacterTextSplitter
 from langchain_community.vectorstores import FAISS
-from sonika_langchain_bot.langchain_bdi import Belief, BotBeliefSystem
 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
@@ -18,35 +15,72 @@ class LangChainBot:
     memoria de conversación y uso de herramientas personalizadas.
     """
 
-    def __init__(self, language_model: ILanguageModel, embeddings: IEmbeddings, beliefs: List[Belief], tools: List[BaseTool]):
+    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
-            beliefs (List[Belief]): Lista de creencias iniciales
+            instructions (str): Instrucciones del sistema
             tools (List[BaseTool]): Lista de herramientas disponibles
         """
         self.language_model = language_model
         self.embeddings = embeddings
-        self.memory = ConversationBufferMemory(return_messages=True)
+        # 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.beliefs = beliefs
-        self.belief_system = BotBeliefSystem('Hal9000', '1.0.0', beliefs_init=beliefs, 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.
-        Ahora incluye el contexto del sistema de creencias.
         """
-        beliefs_context = self.belief_system.generate_prompt_context()
-        full_system_prompt = f"{beliefs_context}\n\n"
-        print(full_system_prompt)
+        full_system_prompt = f"{self.instructions}\n\n"
 
         prompt = ChatPromptTemplate.from_messages([
             SystemMessagePromptTemplate.from_template(full_system_prompt),
@@ -95,14 +129,16 @@ class LangChainBot:
         if context:
             augmented_input = f"Context from attached files:\n{context}\n\nUser question: {user_input}"
 
-        print(augmented_input)
+        # Usamos el historial de chat directamente
+        bot_response = self.conversation.invoke({
+            "input": augmented_input, 
+            "history": self.chat_history
+        })
 
-        bot_response = self.conversation.invoke({"input": augmented_input, "history": self.memory.chat_memory.messages})
-
-        token_usage= bot_response.response_metadata['token_usage']
-        bot_response = bot_response.content
+        token_usage = bot_response.response_metadata.get('token_usage', {})
+        bot_response_content = bot_response.content
         
-        instruction_tool = self._getInstruccionTool(bot_response)
+        instruction_tool = self._getInstruccionTool(bot_response_content)
 
         if instruction_tool:
             messages = [HumanMessage(content=instruction_tool)]
@@ -124,14 +160,14 @@ class LangChainBot:
                     for message in response['agent']['messages']:
                         agent_response = message.content
 
-            bot_response = agent_response if agent_response else tool_response
+            bot_response_content = agent_response if agent_response else tool_response
 
-        user_tokens = token_usage['prompt_tokens']
-        bot_tokens = token_usage['completion_tokens']
+        user_tokens = token_usage.get('prompt_tokens', 0)
+        bot_tokens = token_usage.get('completion_tokens', 0)
 
-        self.save_messages(user_input, bot_response)
+        self.save_messages(user_input, bot_response_content)
 
-        return ResponseModel(user_tokens=user_tokens, bot_tokens=bot_tokens, response=bot_response)
+        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]:
         """
@@ -148,10 +184,20 @@ class LangChainBot:
         if context:
             augmented_input = f"Context from attached files:\n{context}\n\nUser question: {user_input}"
 
-        result_stream = self.conversation.stream({"input": augmented_input, "history": self.memory.chat_memory.messages})
+        # 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:
-            yield response.content
-
+            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:
         """
@@ -172,7 +218,7 @@ class LangChainBot:
         """
         Limpia la memoria de conversación y el almacén de vectores.
         """
-        self.memory.clear()
+        self.chat_history.clear()
         self.vector_store = None
 
     def load_conversation_history(self, messages: List[Message]):
@@ -182,22 +228,23 @@ class LangChainBot:
         Args:
             messages: Lista de objetos Message que representan cada mensaje.
         """
+        self.chat_history.clear()
         for message in messages:
             if message.is_bot:
-                self.memory.chat_memory.add_message(AIMessage(content=message.content))
+                self.chat_history.append(AIMessage(content=message.content))
             else:
-                self.memory.chat_memory.add_message(HumanMessage(content=message.content))
+                self.chat_history.append(HumanMessage(content=message.content))
 
     def save_messages(self, user_message: str, bot_response: str):
         """
-        Guarda los mensajes en la memoria de conversación.
+        Guarda los mensajes en el historial de conversación.
 
         Args:
             user_message (str): Mensaje del usuario
             bot_response (str): Respuesta del bot
         """
-        self.memory.chat_memory.add_message(HumanMessage(content=user_message))
-        self.memory.chat_memory.add_message(AIMessage(content=bot_response))
+        self.chat_history.append(HumanMessage(content=user_message))
+        self.chat_history.append(AIMessage(content=bot_response))
 
     def process_file(self, file: FileProcessorInterface):
         """
@@ -214,3 +261,21 @@ class LangChainBot:
             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()