sonika-langchain-bot 0.0.6__tar.gz → 0.0.7__tar.gz

{sonika_langchain_bot-0.0.6/src/sonika_langchain_bot.egg-info → sonika_langchain_bot-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sonika-langchain-bot
-Version: 0.0.6
+Version: 0.0.7
 Summary: Agente langchain con LLM
 Author: Erley Blanco Carvajal
 License: MIT License
@@ -69,7 +69,7 @@ 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-4-mini-2024-07-18', temperature=1)
+language_model = OpenAILanguageModel(api_key, model_name='gpt-4o-mini', temperature=1)
 embeddings = OpenAIEmbeddings(api_key=api_key)
 
 # Configurar herramientas propias o de terceros
@@ -91,6 +91,19 @@ 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)
+
 ```
 
 ### Ejemplo de Clasificación de Texto
@@ -113,8 +126,8 @@ class Classification(BaseModel):
     )
 
 # Inicializar clasificador
-model = OpenAIModel(api_key=api_key, validation_class=Classification)
-classifier = TextClassifier(api_key=api_key, llm=model, validation_class=Classification)
+model = OpenAILanguageModel(api_key=api_key)
+classifier = TextClassifier(llm=model, validation_class=Classification)
 
 # Clasificar texto
 result = classifier.classify("Tu texto aquí")

{sonika_langchain_bot-0.0.6 → sonika_langchain_bot-0.0.7}/README.md

@@ -37,7 +37,7 @@ 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-4-mini-2024-07-18', temperature=1)
+language_model = OpenAILanguageModel(api_key, model_name='gpt-4o-mini', temperature=1)
 embeddings = OpenAIEmbeddings(api_key=api_key)
 
 # Configurar herramientas propias o de terceros
@@ -59,6 +59,19 @@ 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)
+
 ```
 
 ### Ejemplo de Clasificación de Texto
@@ -81,8 +94,8 @@ class Classification(BaseModel):
     )
 
 # Inicializar clasificador
-model = OpenAIModel(api_key=api_key, validation_class=Classification)
-classifier = TextClassifier(api_key=api_key, llm=model, validation_class=Classification)
+model = OpenAILanguageModel(api_key=api_key)
+classifier = TextClassifier(llm=model, validation_class=Classification)
 
 # Clasificar texto
 result = classifier.classify("Tu texto aquí")

{sonika_langchain_bot-0.0.6 → sonika_langchain_bot-0.0.7}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="sonika-langchain-bot",
-    version="0.0.6", 
+    version="0.0.7", 
     description="Agente langchain con LLM",
     author="Erley Blanco Carvajal",
     license="MIT License",

{sonika_langchain_bot-0.0.6 → sonika_langchain_bot-0.0.7}/src/sonika_langchain_bot/langchain_bot_agent_bdi.py

@@ -1,23 +1,16 @@
 from typing import List
-import tiktoken
 from langchain.memory import ConversationBufferMemory
 from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, HumanMessagePromptTemplate
 from langchain.schema import AIMessage, HumanMessage
 from langchain.text_splitter import CharacterTextSplitter
 from langchain_community.vectorstores import FAISS
-from langchain.chains import LLMChain
 from sonika_langchain_bot.langchain_bdi import Belief, BotBeliefSystem
 from sonika_langchain_bot.langchain_class import FileProcessorInterface, IEmbeddings, ILanguageModel, Message, ResponseModel
-from langchain.tools import Tool
 from langgraph.checkpoint.memory import MemorySaver
 from langgraph.prebuilt import create_react_agent
 from langchain_community.tools import BaseTool
-import inspect
 import re
 
-
-
-
 class LangChainBot:
     """
     Implementación principal del bot conversacional con capacidades de procesamiento de archivos,
@@ -27,11 +20,11 @@ class LangChainBot:
     def __init__(self, language_model: ILanguageModel, embeddings: IEmbeddings, beliefs: List[Belief], 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 (List[str]): Lista de instrucciones para el bot
+            beliefs (List[Belief]): Lista de creencias iniciales
             tools (List[BaseTool]): Lista de herramientas disponibles
         """
         self.language_model = language_model
@@ -41,34 +34,11 @@ class LangChainBot:
         self.vector_store = None
         self.tools = tools
         self.beliefs = beliefs
-        self.belief_system = BotBeliefSystem('Hal9000', '1.0.0',beliefs_init=beliefs,tools=tools )
-        self.conversation = self.create_conversation_chain()
-        self.agent_executor = self.create_agent_executor()
-        
-    def generate_prompt_tools(self, tools: List[BaseTool]):
-        """
-        Carga y procesa las herramientas disponibles para el bot.
-        
-        Args:
-            tools (List[BaseTool]): Lista de herramientas a cargar
-        """
-        text_tools = ""
-        for tool in tools:
-            tool_name = tool.name
-            tool_description = tool.description
-            text_tools += f"Tool Name: {tool_name}\nDescription: {tool_description}\n"
-            run_method = getattr(tool, '_run', None)
-            
-            if run_method:
-                params = inspect.signature(run_method)
-                text_tools += f"Parameters: {params}\n"
-            else:
-                text_tools += "No _run method found.\n"
-            text_tools += "\n---\n"
-
-        return  text_tools
+        self.belief_system = BotBeliefSystem('Hal9000', '1.0.0', beliefs_init=beliefs, tools=tools)
+        self.conversation = self._create_conversation_chain()
+        self.agent_executor = self._create_agent_executor()
 
-    def create_conversation_chain(self):
+    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.
@@ -76,71 +46,72 @@ 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),
             MessagesPlaceholder(variable_name="history"),
             HumanMessagePromptTemplate.from_template("{input}")
         ])
-        return LLMChain(llm=self.language_model.model, prompt=prompt, memory=self.memory)
 
-    def create_agent_executor(self):
+        # 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):
+
+    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)
-        if coincidencia:
-            return coincidencia.group(1).strip()
-        else:
-            return ''
+        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):
+        if context:
             augmented_input = f"Context from attached files:\n{context}\n\nUser question: {user_input}"
+
+        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
         
-        bot_response = self.conversation.predict(input=augmented_input)
-        instruction_tool = self.getInstruccionTool(bot_response)
+        instruction_tool = self._getInstruccionTool(bot_response)
 
         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']:
@@ -148,23 +119,23 @@ class LangChainBot:
                 if 'agent' in response:
                     for message in response['agent']['messages']:
                         agent_response = message.content
-        
+
             bot_response = agent_response if agent_response else tool_response
-                     
-        user_tokens = self.language_model.count_tokens(augmented_input)
-        bot_tokens = self.language_model.count_tokens(bot_response)
 
-        self.save_messages(user_input,bot_response)
+        user_tokens = token_usage['prompt_tokens']
+        bot_tokens = token_usage['completion_tokens']
+
+        self.save_messages(user_input, bot_response)
 
         return ResponseModel(user_tokens=user_tokens, bot_tokens=bot_tokens, response=bot_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
         """
@@ -180,7 +151,7 @@ class LangChainBot:
         self.memory.clear()
         self.vector_store = None
 
-    def load_conversation_history(self, messages: list[Message]):
+    def load_conversation_history(self, messages: List[Message]):
         """
         Carga el historial de conversación previo usando la estructura de mensajes simplificada.
 
@@ -196,7 +167,7 @@ class LangChainBot:
     def save_messages(self, user_message: str, bot_response: str):
         """
         Guarda los mensajes en la memoria de conversación.
-        
+
         Args:
             user_message (str): Mensaje del usuario
             bot_response (str): Respuesta del bot
@@ -207,24 +178,15 @@ class LangChainBot:
     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_total_tokens(self):
-        """
-        Obtiene el total de tokens utilizados en la conversación.
-        
-        Returns:
-            int: Total de tokens
-        """
-        return self.language_model.count_tokens(self.memory.chat_memory.get_messages())

{sonika_langchain_bot-0.0.6 → sonika_langchain_bot-0.0.7}/src/sonika_langchain_bot/langchain_clasificator.py

@@ -1,25 +1,14 @@
 from pydantic import BaseModel
-from langchain_openai import ChatOpenAI
-from langchain_core.messages import HumanMessage
 from typing import Dict, Any, Type
 from sonika_langchain_bot.langchain_class import ILanguageModel
 
-
-class OpenAIModel(ILanguageModel):
-    def __init__(self, api_key: str, model_name: str = "gpt-4o-mini", temperature: float = 0.7, validation_class: Type[BaseModel] = None,):
-        self.model =  ChatOpenAI(api_key=api_key, temperature=temperature, model=model_name).with_structured_output(validation_class)
-
-    def get_response(self, prompt: str) -> str:
-        message = HumanMessage(content=prompt)
-        # Invocar el modelo con el mensaje creado
-        response = self.model.invoke([message])
-        return response
-
 # Clase para realizar la clasificación de texto
 class TextClassifier:
-    def __init__(self, api_key: str, validation_class: Type[BaseModel], llm: ILanguageModel, temperature: float = 0):
+    def __init__(self, validation_class: Type[BaseModel], llm: ILanguageModel):
         self.llm =llm
         self.validation_class = validation_class
+        #configuramos el modelo para que tenga una estructura de salida
+        self.llm.model =  self.llm.model.with_structured_output(validation_class)
 
     def classify(self, text: str) -> Dict[str, Any]:
         # Crear el template del prompt
@@ -30,7 +19,7 @@ class TextClassifier:
         
         Only extract the properties mentioned in the validation class.
         """
-        response = self.llm.get_response(prompt=prompt)
+        response = self.llm.invoke(prompt=prompt)
         
         # Asegurarse de que el `response` es de la clase de validación proporcionada
         if isinstance(response, self.validation_class):

{sonika_langchain_bot-0.0.6 → sonika_langchain_bot-0.0.7}/src/sonika_langchain_bot/langchain_class.py

@@ -7,6 +7,9 @@ class ResponseModel():
         self.user_tokens = user_tokens
         self.bot_tokens = bot_tokens
         self.response = response
+    def __repr__(self):
+        return (f"ResponseModel(user_tokens={self.user_tokens}, "
+                f"bot_tokens={self.bot_tokens}, response={self.response})")
         
 # Definir la interfaz para procesar archivos
 class FileProcessorInterface(ABC):
@@ -16,7 +19,7 @@ class FileProcessorInterface(ABC):
 
 class ILanguageModel(ABC):
     @abstractmethod
-    def get_response(self, prompt: str) -> str:
+    def predict(self, prompt: str) -> str:
         pass
 
 class IEmbeddings(ABC):

{sonika_langchain_bot-0.0.6 → sonika_langchain_bot-0.0.7}/src/sonika_langchain_bot/langchain_models.py

@@ -1,6 +1,8 @@
 from langchain_openai import ChatOpenAI
-import tiktoken
 from sonika_langchain_bot.langchain_class import ILanguageModel
+from langchain_core.messages import HumanMessage
+from typing import  Type
+from pydantic import BaseModel
 
 
 class OpenAILanguageModel(ILanguageModel):
@@ -19,9 +21,8 @@ class OpenAILanguageModel(ILanguageModel):
             temperature (float): Temperatura para la generación de respuestas
         """
         self.model = ChatOpenAI(temperature=temperature, model_name=model_name, api_key=api_key)
-        self.tokenizer = tiktoken.encoding_for_model(model_name)
 
-    def get_response(self, prompt: str) -> str:
+    def predict(self, prompt: str) -> str:
         """
         Genera una respuesta basada en el prompt proporcionado.
         
@@ -32,15 +33,17 @@ class OpenAILanguageModel(ILanguageModel):
             str: Respuesta generada por el modelo
         """
         return self.model.predict(prompt)
-
-    def count_tokens(self, text: str) -> int:
+    
+    def invoke(self, prompt: str) -> str:
         """
-        Cuenta el número de tokens en un texto dado.
-        
+        Invokes the language model with a given prompt and returns the generated response.
+
         Args:
-            text (str): Texto para contar tokens
-            
+            prompt (str): The input text to be processed by the language model.
+
         Returns:
-            int: Número de tokens en el texto
+            str: The response generated by the language model based on the provided prompt.
         """
-        return len(self.tokenizer.encode(text))
+        message = HumanMessage(content=prompt)
+        response = self.model.invoke([message])
+        return response

{sonika_langchain_bot-0.0.6 → sonika_langchain_bot-0.0.7/src/sonika_langchain_bot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sonika-langchain-bot
-Version: 0.0.6
+Version: 0.0.7
 Summary: Agente langchain con LLM
 Author: Erley Blanco Carvajal
 License: MIT License
@@ -69,7 +69,7 @@ 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-4-mini-2024-07-18', temperature=1)
+language_model = OpenAILanguageModel(api_key, model_name='gpt-4o-mini', temperature=1)
 embeddings = OpenAIEmbeddings(api_key=api_key)
 
 # Configurar herramientas propias o de terceros
@@ -91,6 +91,19 @@ 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)
+
 ```
 
 ### Ejemplo de Clasificación de Texto
@@ -113,8 +126,8 @@ class Classification(BaseModel):
     )
 
 # Inicializar clasificador
-model = OpenAIModel(api_key=api_key, validation_class=Classification)
-classifier = TextClassifier(api_key=api_key, llm=model, validation_class=Classification)
+model = OpenAILanguageModel(api_key=api_key)
+classifier = TextClassifier(llm=model, validation_class=Classification)
 
 # Clasificar texto
 result = classifier.classify("Tu texto aquí")

{sonika_langchain_bot-0.0.6 → sonika_langchain_bot-0.0.7}/test/test.py

@@ -5,12 +5,11 @@ from langchain_openai import OpenAIEmbeddings
 from sonika_langchain_bot.langchain_tools import EmailTool
 from sonika_langchain_bot.langchain_bdi import Belief, BeliefType
 from sonika_langchain_bot.langchain_bot_agent_bdi import LangChainBot
-from sonika_langchain_bot.langchain_clasificator import OpenAIModel, TextClassifier
-from sonika_langchain_bot.langchain_class import ResponseModel
+from sonika_langchain_bot.langchain_clasificator import  TextClassifier
+from sonika_langchain_bot.langchain_class import Message, ResponseModel
 from sonika_langchain_bot.langchain_models import OpenAILanguageModel
 from langchain_community.tools.tavily_search import TavilySearchResults
 from pydantic import BaseModel, Field
-from sonika_langchain_bot.langchain_models import OpenAIModel
 
 
 env_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), '.env')
@@ -32,13 +31,18 @@ def bot_bdi():
     beliefs = [Belief(content="Eres un asistente de chat", type=BeliefType.PERSONALITY, confidence=1, source='personality')]
     bot = LangChainBot(language_model, embeddings, beliefs=beliefs, tools=tools)
 
-    user_message = 'Hola como te llamas?'
+    user_message = 'Hola como me llamo?'
+
+    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.response
+    bot_response = response_model
 
     print(bot_response)
 
+
+
+
 # Definir la clase 'Classification' con Pydantic para validar la estructura
 class Classification(BaseModel):
     intention: str = Field()
@@ -54,10 +58,10 @@ class Classification(BaseModel):
 
 def clasification():
     api_key = os.getenv("OPENAI_API_KEY")
-    model = OpenAIModel(api_key=api_key,validation_class=Classification)
-    classifier = TextClassifier(api_key=api_key,llm=model, validation_class=Classification)
-    result = classifier.classify("venga, quiero que vengas a mi casa y nos tomamos un vino tu y yo solos, en mi cuarto sin ropa, que dices")
+    model = OpenAILanguageModel(api_key=api_key)
+    classifier = TextClassifier(llm=model, validation_class=Classification)
+    result = classifier.classify("how are you?")
     print(result)
 
-bot_bdi()
-#clasification()
+#bot_bdi()
+clasification()