Guía del autoestopista para el trapo con la API Chatgpt y Langchain

Genere toneladas de palabras y respuestas basadas en el conocimiento general, pero ¿qué sucede cuando necesitamos respuestas que requieran un conocimiento preciso y específico? Los modelos generativos únicos con frecuencia luchan por proporcionar respuestas sobre preguntas específicas del dominio por un montón de razones; Tal vez los datos en los que fueron entrenados ahora están desactualizados, tal vez lo que estamos pidiendo es en realidad Específico y especializado, tal vez queremos respuestas que tengan en cuenta los datos personales o corporativos que simplemente no son públicos … 🤷‍♀️ La lista continúa.

Entonces, ¿cómo podemos aprovechar la IA generativa mientras mantienen nuestras respuestas precisas, relevantes y con los pies en la tierra? Una buena respuesta a esta pregunta es la Generación de recuperación de generación (trapo) estructura. RAG es un marco que consta de dos componentes clave: recuperación y generación (¡duh!). A diferencia de los modelos únicamente generativos que se entrenan previamente en datos específicos, RAG incorpora un paso adicional de recuperación que nos permite impulsar información adicional al modelo desde una fuente externa, como una base de datos o un documento. Para decirlo de manera diferente, una tubería de RAG permite proporcionar respuestas coherentes y naturales (proporcionadas por el paso de generación), que también son objetivos y fundamentados en una base de conocimiento de nuestra elección (proporcionada por el paso de recuperación).

De esta manera, RAG puede ser una herramienta extremadamente valiosa para aplicaciones donde se necesitan datos altamente especializados, como por ejemplo, atención al cliente, asesoramiento legal o documentación técnica. Un ejemplo típico de una aplicación RAG son los chatbots de atención al cliente, respondiendo los problemas de los clientes basados ​​en la base de datos de documentos de soporte y las preguntas frecuentes de una empresa. Otro ejemplo sería el software o productos técnicos complejos con amplias guías de solución de problemas. Un ejemplo más sería un asesoramiento legal: un modelo de RAG accedería y recuperaría datos personalizados de bibliotecas de derecho, casos anteriores o directrices firmes. Los ejemplos son realmente interminables; Sin embargo, en todos estos casos, el acceso a los datos externos, específicos y relevantes para los contextos permite que el modelo ofrezca respuestas más precisas y precisas.

Entonces, en esta publicación, te guíe a través de la construcción de una tubería de trapo simple en Python, utilizando la API Chatgpt, Langchain y Faiss.

¿Qué pasa con el trapo?

Desde una perspectiva más técnica, RAG es una técnica utilizada para mejorar las respuestas de una LLM inyectándola con información adicional específica de dominio. En esencia, RAG permite que un modelo también tenga en cuenta información externa adicional, como un libro de recetas, un manual técnico o la base de conocimiento interno de una empresa, mientras forma sus respuestas.

Esto es muy importante porque nos permite eliminar un montón de problemas inherentes a LLMS, como por ejemplo:

• Alucinaciones – inventando las cosas
• Información anticuada: si el modelo no estaba capacitado en datos recientes
• Transparencia: sin saber de dónde provienen las respuestas

Para hacer que esto funcione, los documentos externos se procesan primero en integridades vectoriales y se almacenan en una base de datos vectorial. Luego, cuando enviamos un aviso a la LLM, se recuperan los datos relevantes de la base de datos Vector y se pasa a la LLM junto con nuestro mensaje. Como resultado, la respuesta de la LLM se forma considerando nuestra información rápida y relevante existente en la base de datos de vectores en segundo plano. Dicha base de datos vectorial se puede alojar localmente o en la nube, utilizando un servicio como Piñao Tejido.

¿Qué pasa con la API ChatGPT, Langchain y Faiss?

El primer componente para construir una tubería RAG es el modelo LLM que generará las respuestas. Esto puede ser cualquier LLM, como Gemini o Claude, pero en esta publicación, usaré el chatgpt de OpenAi modelos a través de su Plataforma API. Para usar su API, necesitamos iniciar sesión y obtener una clave API. También debemos asegurarnos de que se instalen las respectivas bibliotecas de Python.

pip install openai

El otro componente importante de la construcción de un RAG es procesar datos externos: generar integridades a partir de documentos y almacenarlos en una base de datos vectorial. El marco más popular para realizar tal tarea es Langchain. En particular, Langchain permite:

• Cargar y extraer texto de varios tipos de documentos (PDFS, DOCX, TXT, etc.)
• Dividir el texto en trozos adecuados para generar los incrustaciones
• Genere incrustaciones de vectores (en esta publicación, con la ayuda de la API de Operai)
• Almacenar y buscar integridades a través de bases de datos vectoriales como Faiss, Cromay Piña

Podemos instalar fácilmente las bibliotecas Langchain requeridas por:

pip install langchain langchain-community langchain-openai

En esta publicación, usaré Langchain junto con Faiss una base de datos vectorial local desarrollada por Facebook AI Research. FAISS es un paquete muy liviano y, por lo tanto, es apropiado para construir una tubería de trapo simple/pequeña. Se puede instalar fácilmente con:

pip install faiss-cpu

Poniendo todo junto

Entonces, en resumen, usaré:

• Modelos ChatGPT a través de la API de OpenAi como el LLM
• Langchain, junto con la API de OpenAi, para cargar los archivos externos, procesarlos y generar los incrustaciones de vectores
• FAISS para generar una base de datos vectorial local

El archivo que alimentaré en la tubería RAG para esta publicación es un archivo de texto con algunos hechos sobre mí. Este archivo de texto se encuentra en la carpeta ‘Archivos RAG’.

Ahora estamos todos configurados, y podemos comenzar especificando nuestra clave API e inicializando nuestro modelo:

from openai import OpenAI # Chat_GPT API key api_key = "your key" 

# initialize LLM 
llm = ChatOpenAI(openai_api_key=api_key, model="gpt-4o-mini", temperature=0.3)

Luego podemos cargar los archivos que queremos usar para el trapo, generar los incrustaciones y almacenarlos como una base de datos vectorial de la siguiente manera:

# loading documents to be used for RAG 
text_folder = "rag_files"  

all_documents = []
for filename in os.listdir(text_folder):
    if filename.lower().endswith(".txt"):
        file_path = os.path.join(text_folder, filename)
        loader = TextLoader(file_path)
        all_documents.extend(loader.load())

# generate embeddings
embeddings = OpenAIEmbeddings(openai_api_key=api_key)

# create vector database w FAISS 
vector_store = FAISS.from_documents(documents, embeddings)
retriever = vector_store.as_retriever()

Finalmente, podemos envolver todo en un archivo de Python ejecutable simple:

def main():
    print("Welcome to the RAG Assistant. Type 'exit' to quit.\n")
    
    while True:
        user_input = input("You: ").strip()
        if user_input.lower() == "exit":
            print("Exiting…")
            break

        # get relevant documents
        relevant_docs = retriever.get_relevant_documents(user_input)
        retrieved_context = "\n\n".join([doc.page_content for doc in relevant_docs])

        # system prompt
        system_prompt = (
            "You are a helpful assistant. "
            "Use ONLY the following knowledge base context to answer the user. "
            "If the answer is not in the context, say you don't know.\n\n"
            f"Context:\n{retrieved_context}"
        )

        # messages for LLM 
        messages = [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_input}
        ]

        # generate response
        response = llm.invoke(messages)
        assistant_message = response.content.strip()
        print(f"\nAssistant: {assistant_message}\n")

if __name__ == "__main__":
    main()

Observe cómo se define el mensaje del sistema. Esencialmente, un mensaje de sistema es una instrucción dada al LLM que establece el comportamiento, el tono o las limitaciones del asistente antes de que el usuario interactúe. Por ejemplo, podríamos establecer el indicador del sistema para que la LLM proporcione respuestas como hablar con un niño de 4 años o un científico de cohetes; aquí pedimos que proporcione respuestas solo en función de los datos externos que proporcionamos, el ”Hechos de María‘

Entonces, ¡veamos qué hemos cocinado! 🍳

En primer lugar, hago una pregunta que es irrelevante para la fuente de datos externa proporcionada, para asegurarme de que el modelo solo use la fuente de datos proporcionada al formar las respuestas y no el conocimiento general.

… y luego hice algunas preguntas específicamente desde el archivo que proporcioné …

✨✨✨✨

En mi mente

Aparentemente, este es un ejemplo muy simplista de una configuración de trapo: hay mucho más que considerar al implementarlo en un entorno empresarial real, como las preocupaciones de seguridad sobre cómo se manejan los datos o los problemas de rendimiento al tratar con un corpus de conocimiento más grande y más realista y un mayor uso de tokens. No obstante, creo que la API de Openai es realmente impresionante y ofrece un potencial inmenso y sin explotar para construir aplicaciones de IA personalizadas y específicas del contexto.

¿Me encantó esta publicación? ¡Seamos amigos! Unirse a mí

📰Sustitución 💌 Medio 💼LinkedIn☕Cómprame un café!