sonika-langchain-bot 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

sonika_langchain_bot/langchain_bdi.py

@@ -0,0 +1,183 @@
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set
+from datetime import datetime
+import json
+from enum import Enum
+from langchain.tools import Tool
+import inspect
+
+class BeliefType(Enum):
+    CORE = "core"              # Creencias fundamentales sobre sí mismo
+    PERSONALITY = "personality" # Rasgos de personalidad
+    USER = "user"              # Creencias sobre el usuario
+    CONTEXT = "context"        # Creencias sobre el contexto actual
+    KNOWLEDGE = "knowledge"    # Conocimiento general
+    TEMPORAL = "temporal"      # Creencias temporales
+    TOOLS = "tools"      # Creencias temporales
+
+
+@dataclass
+class Belief:
+    """Representa una creencia individual del bot."""
+    content: str
+    type: BeliefType
+    confidence: float = 1.0
+    created_at: datetime = field(default_factory=datetime.now)
+    last_updated: datetime = field(default_factory=datetime.now)
+    source: str = "initial"
+
+@dataclass
+class Desire:
+    """Representa un deseo o objetivo del bot."""
+    description: str
+    priority: int
+    conditions: List[str]
+    achieved: bool = False
+
+@dataclass
+class Intention:
+    """Representa una intención o plan de acción del bot."""
+    description: str
+    steps: List[str]
+    related_desire: str
+    completed: bool = False
+
+class BotBeliefSystem:
+    """Sistema principal de creencias del bot."""
+    
+    def __init__(self, bot_name: str, bot_version: str, tools: List[Tool], beliefs_init: List[Belief]):
+        self.bot_name = bot_name
+        self.bot_version = bot_version
+        self.beliefs_init = beliefs_init
+        self.beliefs: Dict[BeliefType, Dict[str, Belief]] = {belief_type: {} for belief_type in BeliefType}
+        self.desires: List[Desire] = []
+        self.intentions: List[Intention] = []
+        self.conversation_history: List[Dict] = []
+        self._initialize_core_beliefs()
+        self.add_tools_beliefs(tools)
+        self.set_beliefs_init()
+    
+    def set_beliefs_init(self):
+        for belief in self.beliefs_init:
+            self.add_belief(belief)
+        
+    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
+        ]
+        
+        for belief in core_beliefs:
+            self.add_belief(belief)
+
+    def add_tools_beliefs(self, tools: List[Tool]):
+        """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.
+                                \nEnsure you gather all relevant information from the conversation to use the parameters.
+                                \nIf information is missing, search online.'''
+        
+        # Agregar un encabezado para la lista de herramientas
+        instrucciones_de_uso = instrucciones_de_uso + "\nThis is a list of the tools you can execute:"
+        # Almacenar las instrucciones de uso como una creencia
+        self.add_belief(Belief(content=instrucciones_de_uso, type=BeliefType.TOOLS))
+
+        # Procesar cada herramienta y almacenarla como creencia
+        for tool in tools:
+            tool_name = tool.name
+            tool_description = tool.description
+            
+            # Crear un texto para la herramienta
+            tool_text = f"Tool Name: {tool_name}\nDescription: {tool_description}\n"
+            run_method = getattr(tool, '_run', None)
+            
+            if run_method:
+                params = inspect.signature(run_method)
+                tool_text += f"Parameters: {params}\n"
+            else:
+                tool_text += "No _run method found.\n"
+            
+            tool_text += "\n---\n"
+            
+            # Almacenar la herramienta como una creencia
+            self.add_belief(Belief(content=tool_text.strip(), type=BeliefType.TOOLS))
+
+        
+    def add_belief(self, belief: Belief):
+        """Agrega o actualiza una creencia."""
+        self.beliefs[belief.type][str(datetime.now())] = belief
+    
+    def get_beliefs_by_type(self, belief_type: BeliefType) -> List[Belief]:
+        """Obtiene todas las creencias de un tipo específico."""
+        return list(self.beliefs[belief_type].values())
+    
+    def add_desire(self, desire: Desire):
+        """Agrega un nuevo deseo."""
+        self.desires.append(desire)
+        self.desires.sort(key=lambda x: x.priority, reverse=True)
+    
+    def add_intention(self, intention: Intention):
+        """Agrega una nueva intención."""
+        self.intentions.append(intention)
+    
+    def update_user_belief(self, key: str, value: str):
+        """Actualiza una creencia sobre el usuario."""
+        belief = Belief(
+            content=f"{key}: {value}",
+            type=BeliefType.USER,
+            confidence=0.8,
+            source="user_interaction"
+        )
+        self.add_belief(belief)
+    
+    def get_current_context(self) -> str:
+        """Obtiene el contexto actual basado en las creencias."""
+        context_beliefs = self.get_beliefs_by_type(BeliefType.CONTEXT)
+        return "\n".join([belief.content for belief in context_beliefs])
+    
+    def generate_prompt_context(self) -> str:
+        """Genera el contexto para el prompt, incluyendo creencias y guías sobre cómo el agente debe utilizar esta información."""
+        context_parts = []
+
+        # Instrucciones base para el agente BDI
+        instructions = [
+            '''''',
+        ]
+        context_parts.extend(instructions)
+
+        # Agregar información de creencias núcleo (Core Beliefs)
+        core_beliefs = self.get_beliefs_by_type(BeliefType.CORE)
+        context_parts.append("\nCore Beliefs:")
+        context_parts.extend([f"- {belief.content}" for belief in core_beliefs])
+
+        # Agregar información de personalidad (Personality Traits)
+        personality_beliefs = self.get_beliefs_by_type(BeliefType.PERSONALITY)
+        if personality_beliefs:
+            # Agregar una sección de escala de intensidad y los rasgos de personalidad al contexto
+            context_parts.append("\nPersonality Traits:\n")
+            # Agregar los rasgos de personalidad de la lista
+            context_parts.extend([f"- {belief.content}" for belief in personality_beliefs])
+
+        # Agregar información del usuario (User Information)
+        user_beliefs = self.get_beliefs_by_type(BeliefType.USER)
+        if user_beliefs:
+            context_parts.append("\nUser Information:")
+            context_parts.extend([f"- {belief.content}" for belief in user_beliefs])
+
+        user_beliefs = self.get_beliefs_by_type(BeliefType.TOOLS)
+        if user_beliefs:
+            context_parts.append("\nTools Information:")
+            context_parts.extend([f"- {belief.content}" for belief in user_beliefs])
+
+        # Generación final del prompt
+        return "\n".join(context_parts)

sonika_langchain_bot/langchain_bot_agent_bdi.py

@@ -0,0 +1,230 @@
+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,
+    memoria de conversación y uso de herramientas personalizadas.
+    """
+
+    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
+            tools (List[BaseTool]): Lista de herramientas disponibles
+        """
+        self.language_model = language_model
+        self.embeddings = embeddings
+        self.memory = ConversationBufferMemory(return_messages=True)
+        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.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
+
+    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)
+        
+        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):
+        """
+        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)
+        if coincidencia:
+            return coincidencia.group(1).strip()
+        else:
+            return ''
+
+    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}"
+        
+        bot_response = self.conversation.predict(input=augmented_input)
+        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']:
+                        tool_response = message.content
+                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)
+
+        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
+        """
+        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.memory.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.
+        """
+        for message in messages:
+            if message.is_bot:
+                self.memory.chat_memory.add_message(AIMessage(content=message.content))
+            else:
+                self.memory.chat_memory.add_message(HumanMessage(content=message.content))
+
+    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
+        """
+        self.memory.chat_memory.add_message(HumanMessage(content=user_message))
+        self.memory.chat_memory.add_message(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_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/langchain_clasificator.py

@@ -0,0 +1,41 @@
+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):
+        self.llm =llm
+        self.validation_class = validation_class
+
+    def classify(self, text: str) -> Dict[str, Any]:
+        # Crear el template del prompt
+        prompt = f"""
+        Classify the following text based on the properties defined in the validation class.
+        
+        Text: {text}
+        
+        Only extract the properties mentioned in the validation class.
+        """
+        response = self.llm.get_response(prompt=prompt)
+        
+        # Asegurarse de que el `response` es de la clase de validación proporcionada
+        if isinstance(response, self.validation_class):
+            # Crear el resultado dinámicamente basado en los atributos de la clase de validación
+            result = {field: getattr(response, field) for field in self.validation_class.__fields__.keys()}
+            return result
+        else:
+            raise ValueError(f"The response is not of type '{self.validation_class.__name__}'")

sonika_langchain_bot/langchain_class.py

@@ -0,0 +1,41 @@
+from abc import ABC, abstractmethod
+from typing import List
+
+
+class ResponseModel():
+    def __init__(self, user_tokens=None, bot_tokens=None,  response = None):
+        self.user_tokens = user_tokens
+        self.bot_tokens = bot_tokens
+        self.response = response
+        
+# Definir la interfaz para procesar archivos
+class FileProcessorInterface(ABC):
+    @abstractmethod
+    def getText(self):
+        pass
+
+class ILanguageModel(ABC):
+    @abstractmethod
+    def get_response(self, prompt: str) -> str:
+        pass
+
+class IEmbeddings(ABC):
+    @abstractmethod
+    def embed_documents(self, documents: List[str]):
+        pass
+
+    @abstractmethod
+    def embed_query(self, query: str):
+        pass
+
+class Message:
+    """
+    Clase para representar un mensaje con un indicador de si es del bot y su contenido.
+    """
+    def __init__(self, is_bot: bool, content: str):
+        self.is_bot = is_bot
+        self.content = content
+
+
+        
+

sonika_langchain_bot/langchain_files.py

@@ -0,0 +1,12 @@
+from langchain_community.document_loaders import PyPDFLoader
+from sonika_langchain_bot.langchain_class import FileProcessorInterface
+
+
+class PDFProcessor(FileProcessorInterface):
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+
+    def getText(self):
+        loader = PyPDFLoader(self.file_path)
+        documents = loader.load()
+        return documents

sonika_langchain_bot/langchain_models.py

@@ -0,0 +1,46 @@
+from langchain_openai import ChatOpenAI
+import tiktoken
+from sonika_langchain_bot.langchain_class import ILanguageModel
+
+
+class OpenAILanguageModel(ILanguageModel):
+    """
+    Clase que implementa la interfaz ILanguageModel para interactuar con los modelos de lenguaje de OpenAI.
+    Proporciona funcionalidades para generar respuestas y contar tokens.
+    """
+
+    def __init__(self, api_key: str, model_name: str = "gpt-4o-mini", temperature: float = 0.7):
+        """
+        Inicializa el modelo de lenguaje de OpenAI.
+        
+        Args:
+            api_key (str): Clave API de OpenAI
+            model_name (str): Nombre del modelo a utilizar
+            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:
+        """
+        Genera una respuesta basada en el prompt proporcionado.
+        
+        Args:
+            prompt (str): Texto de entrada para generar la respuesta
+            
+        Returns:
+            str: Respuesta generada por el modelo
+        """
+        return self.model.predict(prompt)
+
+    def count_tokens(self, text: str) -> int:
+        """
+        Cuenta el número de tokens en un texto dado.
+        
+        Args:
+            text (str): Texto para contar tokens
+            
+        Returns:
+            int: Número de tokens en el texto
+        """
+        return len(self.tokenizer.encode(text))

sonika_langchain_bot/langchain_tools.py

@@ -0,0 +1,14 @@
+from langchain_community.tools import BaseTool
+# Crear una clase que herede de BaseTool
+from pydantic import BaseModel
+
+class EmailTool(BaseTool, BaseModel):
+    name: str = "EmailTool"
+    description: str = "Esta herramienta envía correos electrónicos."
+
+    def _run(self, to_email: str, subject: str, message: str) -> str:
+        
+        if True:
+            return "Correo enviado con éxito."
+        else:
+            return "No se pudo enviar el correo."

{sonika_langchain_bot-0.0.4.dist-info → sonika_langchain_bot-0.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sonika-langchain-bot
-Version: 0.0.4
+Version: 0.0.5
 Summary: Agente langchain con LLM
 Author: Erley Blanco Carvajal
 License: MIT License
@@ -10,22 +10,22 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: langchain ==0.3.0
-Requires-Dist: langchain-community ==0.3.0
-Requires-Dist: langchain-core ==0.3.5
-Requires-Dist: langchain-openai ==0.2.0
-Requires-Dist: langgraph ==0.2.39
-Requires-Dist: langgraph-checkpoint ==2.0.2
-Requires-Dist: langgraph-sdk ==0.1.34
-Requires-Dist: dataclasses-json ==0.6.7
-Requires-Dist: python-dateutil ==2.9.0.post0
-Requires-Dist: tiktoken ==0.7.0
-Requires-Dist: pydantic ==2.9.2
-Requires-Dist: faiss-cpu ==1.8.0.post1
-Requires-Dist: pypdf ==5.0.0
-Requires-Dist: python-dotenv ==1.0.1
-Requires-Dist: typing-extensions ==4.12.0
-Requires-Dist: typing-inspect ==0.9.0
+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-0.0.5.dist-info/RECORD

@@ -0,0 +1,13 @@
+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=ueN2dP8nuBO9gV81sXIEP8BrWK8b3jglpDNSOIsPa58,9005
+sonika_langchain_bot/langchain_clasificator.py,sha256=_58LRwd2G8u-KKgFnp9FSZtxBg4vyVbeD5aS5ny4Hcs,1889
+sonika_langchain_bot/langchain_class.py,sha256=tPc_aKbhYYv1DUwIEuaDDFpIwKOdfmMuJWOKjX6Iyco,953
+sonika_langchain_bot/langchain_files.py,sha256=SEyqnJgBc_nbCIG31eypunBbO33T5AHFOhQZcghTks4,381
+sonika_langchain_bot/langchain_models.py,sha256=8gC7rDxGI0JcNn-MADyLQ5rK8mgOS1iVjLsV8kCQi9k,1578
+sonika_langchain_bot/langchain_tools.py,sha256=y7wLf1DbUua3QIvz938Ek-JIMOuQhrOIptJadW8OIsU,466
+sonika_langchain_bot-0.0.5.dist-info/LICENSE,sha256=O8VZ4aU_rUMAArvYTm2bshcZ991huv_tpfB5BKHH9Q8,1064
+sonika_langchain_bot-0.0.5.dist-info/METADATA,sha256=eVnVxq9Oo89qa_g8k2DgBTsBftt-ruac2BHhSKodgDw,1447
+sonika_langchain_bot-0.0.5.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+sonika_langchain_bot-0.0.5.dist-info/top_level.txt,sha256=UsTTSZFEw2wrPSVh4ufu01e2m_E7O_QVYT_k4zCQaAE,21
+sonika_langchain_bot-0.0.5.dist-info/RECORD,,

sonika_langchain_bot-0.0.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+sonika_langchain_bot

sonika_langchain_bot-0.0.4.dist-info/RECORD

@@ -1,5 +0,0 @@
-sonika_langchain_bot-0.0.4.dist-info/LICENSE,sha256=O8VZ4aU_rUMAArvYTm2bshcZ991huv_tpfB5BKHH9Q8,1064
-sonika_langchain_bot-0.0.4.dist-info/METADATA,sha256=XSX_2JIJDb9qoAVBeLKEStw1Cs0jk_J0LBxBgikTN38,1347
-sonika_langchain_bot-0.0.4.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-sonika_langchain_bot-0.0.4.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-sonika_langchain_bot-0.0.4.dist-info/RECORD,,

sonika_langchain_bot-0.0.4.dist-info/top_level.txt

@@ -1 +0,0 @@
-