De cero a avanzado en la ingeniería de comandos con Langchain en Python

From beginner to advanced in command engineering with Langchain in Python

Un aspecto importante de los Modelos de Lenguaje Grande (LLMs) es la cantidad de parámetros que estos modelos utilizan para el aprendizaje. Cuantos más parámetros tiene un modelo, mejor puede comprender la relación entre palabras y frases. Esto significa que los modelos con miles de millones de parámetros tienen la capacidad de generar diversos formatos de texto creativo y responder preguntas abiertas y desafiantes de manera informativa.

LLMs como ChatGPT, que utilizan el modelo Transformer, son proficientes en la comprensión y generación del lenguaje humano, lo que los hace útiles para aplicaciones que requieren comprensión del lenguaje natural. Sin embargo, no están exentos de limitaciones, que incluyen conocimientos desactualizados, incapacidad para interactuar con sistemas externos, falta de comprensión del contexto y a veces generación de respuestas que suenan plausibles pero incorrectas o sin sentido, entre otros.

Abordar estas limitaciones requiere integrar LLMs con fuentes de datos y capacidades externas, lo que puede presentar complejidades y demandar habilidades extensas de codificación y manejo de datos. Esto, junto con los desafíos de comprender conceptos de IA y algoritmos complejos, contribuye a la curva de aprendizaje asociada con el desarrollo de aplicaciones utilizando LLMs.

• Conoce MovieChat un innovador sistema de comprensión de video que integra modelos fundamentales de video y grandes modelos de lenguaje.
• IA Generativa en la Salud
• V-Net, el hermano mayor de U-Net en la segmentación de imágenes

No obstante, la integración de LLMs con otras herramientas para formar aplicaciones impulsadas por LLM podría redefinir nuestro panorama digital. El potencial de dichas aplicaciones es vasto, e incluye mejorar eficiencia y productividad, simplificar tareas, mejorar la toma de decisiones y brindar experiencias personalizadas.

En este artículo, profundizaremos en estos temas, explorando las técnicas avanzadas de ingeniería de comandos con Langchain, ofreciendo explicaciones claras, ejemplos prácticos e instrucciones paso a paso sobre cómo implementarlos.

Langchain, una biblioteca de última generación, brinda conveniencia y flexibilidad para diseñar, implementar y ajustar comandos. A medida que desglosemos los principios y prácticas de la ingeniería de comandos, aprenderá cómo utilizar las poderosas características de Langchain para aprovechar las fortalezas de los modelos generativos SOTA como GPT-4.

Entendiendo los Comandos

Antes de adentrarnos en los aspectos técnicos de la ingeniería de comandos, es esencial comprender el concepto de los comandos y su importancia.

Un ‘comando’ es una secuencia de tokens que se utiliza como entrada a un modelo de lenguaje, indicándole que genere un tipo específico de respuesta. Los comandos juegan un papel crucial en dirigir el comportamiento de un modelo. Pueden afectar la calidad del texto generado y, cuando se diseñan correctamente, pueden ayudar al modelo a proporcionar resultados perspicaces, precisos y específicos del contexto.

La ingeniería de comandos es el arte y la ciencia de diseñar comandos efectivos. El objetivo es obtener la salida deseada de un modelo de lenguaje. Al seleccionar y estructurar cuidadosamente los comandos, se puede guiar al modelo para que genere respuestas más precisas y relevantes. En la práctica, esto implica ajustar las frases de entrada para adaptarse a los sesgos de entrenamiento y estructurales del modelo.

La sofisticación de la ingeniería de comandos varía desde técnicas simples, como proporcionar palabras clave relevantes al modelo, hasta métodos más avanzados que involucran el diseño de comandos complejos y estructurados que aprovechan los mecanismos internos del modelo a su favor.

Langchain: La Herramienta de Comandos de Crecimiento Más Rápido

LangChain, lanzado en octubre de 2022 por Harrison Chase, se ha convertido en uno de los frameworks de código abierto más valorados en GitHub en 2023. Ofrece una interfaz simplificada y estandarizada para incorporar Modelos de Lenguaje Grande (LLMs) en aplicaciones. También proporciona una interfaz rica en funciones para la ingeniería de comandos, lo que permite a los desarrolladores experimentar con diferentes estrategias y evaluar sus resultados. Al utilizar Langchain, puede realizar tareas de ingeniería de comandos de manera más efectiva e intuitiva.

LangFlow sirve como una interfaz de usuario para orquestar los componentes de LangChain en un diagrama de flujo ejecutable, lo que permite una rápida creación de prototipos y experimentación.

LangChain cubre una brecha crucial en el desarrollo de IA para las masas. Permite una variedad de aplicaciones de procesamiento del lenguaje natural como asistentes virtuales, generadores de contenido, sistemas de preguntas y respuestas, y más, para resolver una variedad de problemas del mundo real.

En lugar de ser un modelo o proveedor independiente, LangChain simplifica la interacción con modelos diversos, ampliando las capacidades de las aplicaciones de LLM más allá de las limitaciones de una simple llamada a una API.

La Arquitectura de LangChain

 

Los componentes principales de LangChain incluyen Model I/O, Plantillas de Comandos, Memoria, Agentes y Cadenas.

Modelo I/O

LangChain facilita una conexión fluida con varios modelos de lenguaje al envolverlos con una interfaz estandarizada conocida como Modelo I/O. Esto facilita un cambio de modelo sin esfuerzo para la optimización o mejor rendimiento. LangChain admite varios proveedores de modelos de lenguaje, incluyendo OpenAI, HuggingFace, Azure, Fireworks y más.

Plantillas de Instrucciones

Se utilizan para gestionar y optimizar las interacciones con los LLMs al proporcionar instrucciones o ejemplos concisos. La optimización de las instrucciones mejora el rendimiento del modelo y su flexibilidad contribuye significativamente al proceso de entrada.

Un ejemplo sencillo de una plantilla de instrucciones:

from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=["tema"],
template="¿Cuáles son los avances recientes en el campo de {tema}?")
print(prompt.format(tema="Procesamiento del Lenguaje Natural"))

A medida que avanzamos en complejidad, nos encontramos con patrones más sofisticados en LangChain, como el patrón Razón y Acción (ReAct). ReAct es un patrón vital para la ejecución de acciones donde el agente asigna una tarea a una herramienta adecuada, personaliza la entrada para ella y analiza su salida para lograr la tarea. El ejemplo de Python a continuación muestra un patrón ReAct. Demuestra cómo se estructura una instrucción en LangChain, utilizando una serie de pensamientos y acciones para razonar a través de un problema y producir una respuesta final:

PREFIX = """Responde la siguiente pregunta utilizando las herramientas proporcionadas:"""
FORMAT_INSTRUCTIONS = """Sigue este formato:
Pregunta: {input_question}
Pensamiento: tu pensamiento inicial sobre la pregunta
Acción: tu acción elegida de [{tool_names}]
Entrada de Acción: tu entrada para la acción
Observación: el resultado de la acción"""
SUFFIX = """¡Comienza!
Pregunta: {input}
Pensamiento:{agent_scratchpad}"""

Memoria

La memoria es un concepto crítico en LangChain, que permite a los LLMs y herramientas retener información a lo largo del tiempo. Este comportamiento con estado mejora el rendimiento de las aplicaciones de LangChain al almacenar respuestas anteriores, interacciones del usuario, el estado del entorno y los objetivos del agente. Las estrategias ConversationBufferMemory y ConversationBufferWindowMemory ayudan a realizar un seguimiento de las partes completas o recientes de una conversación, respectivamente. Para un enfoque más sofisticado, la estrategia ConversationKGMemory permite codificar la conversación como un grafo de conocimiento que se puede retroalimentar en instrucciones o utilizar para predecir respuestas sin llamar al LLM.

Agentes

Un agente interactúa con el mundo realizando acciones y tareas. En LangChain, los agentes combinan herramientas y cadenas para la ejecución de tareas. Pueden establecer una conexión con el mundo exterior para la recuperación de información y así aumentar el conocimiento de los LLMs, superando sus limitaciones inherentes. Pueden decidir pasar cálculos a una calculadora o intérprete de Python dependiendo de la situación.

Los agentes están equipados con subcomponentes:

• Herramientas: Estos son componentes funcionales.
• Paquetes de herramientas: Colecciones de herramientas.
• Agent Executors: Este es el mecanismo de ejecución que permite elegir entre herramientas.

Los agentes en LangChain también siguen el patrón Zero-shot ReAct, donde la decisión se basa únicamente en la descripción de la herramienta. Este mecanismo se puede ampliar con la memoria para tener en cuenta todo el historial de conversación. Con ReAct, en lugar de pedirle a un LLM que complete tu texto, puedes pedirle que responda en un ciclo de pensamiento/acción/observación.

Cadenas

Las cadenas, como sugiere el término, son secuencias de operaciones que permiten que la biblioteca LangChain procese las entradas y salidas del modelo de lenguaje de manera fluida. Estos componentes integrales de LangChain están compuestos fundamentalmente por enlaces, que pueden ser otras cadenas o elementos primitivos como instrucciones, modelos de lenguaje o utilidades.

Imagina una cadena como una cinta transportadora en una fábrica. Cada paso en esta cinta representa una determinada operación, que podría ser invocar un modelo de lenguaje, aplicar una función de Python a un texto o incluso solicitarle al modelo una respuesta de una manera particular.

LangChain categoriza sus cadenas en tres tipos: cadenas de utilidad, cadenas genéricas y cadenas de combinación de documentos. Nos centraremos en las cadenas de utilidad y las cadenas genéricas para nuestra discusión.

• Las cadenas de utilidad están diseñadas específicamente para extraer respuestas precisas de los modelos de lenguaje para tareas definidas de manera estrecha. Por ejemplo, veamos la cadena LLMMathChain. Esta cadena de utilidad permite que los modelos de lenguaje realicen cálculos matemáticos. Acepta una pregunta en lenguaje natural y, a su vez, el modelo de lenguaje genera un fragmento de código Python que se ejecuta para producir la respuesta.
• Por otro lado, las cadenas genéricas sirven como bloques de construcción para otras cadenas pero no se pueden utilizar directamente por sí solas. Estas cadenas, como la cadena LLMChain, son fundamentales y se combinan frecuentemente con otras cadenas para llevar a cabo tareas complejas. Por ejemplo, la cadena LLMChain se utiliza con frecuencia para consultar un objeto de modelo de lenguaje mediante el formato de entrada basado en una plantilla de instrucciones proporcionada y luego pasarlo al modelo de lenguaje.

Implementación paso a paso de Engineering de Prompts con Langchain

Te guiaremos en el proceso de implementación de engineering de prompts utilizando Langchain. Antes de continuar, asegúrate de haber instalado el software y los paquetes necesarios.

Puedes aprovechar herramientas populares como Docker, Conda, Pip y Poetry para configurar LangChain. Los archivos de instalación relevantes para cada uno de estos métodos se pueden encontrar dentro del repositorio de LangChain en https://github.com/benman1/generative_ai_with_langchain. Esto incluye un Dockerfile para Docker, un requirements.txt para Pip, un pyproject.toml para Poetry y un archivo langchain_ai.yml para Conda.

En nuestro artículo utilizaremos Pip, el gestor de paquetes estándar para Python, para facilitar la instalación y gestión de bibliotecas de terceros. Si no está incluido en tu distribución de Python, puedes instalar Pip siguiendo las instrucciones en https://pip.pypa.io/.

Para instalar una biblioteca con Pip, utiliza el comando pip install nombre_biblioteca.

Sin embargo, Pip no gestiona entornos por sí solo. Para manejar diferentes entornos, utilizamos la herramienta virtualenv.

En la siguiente sección, discutiremos las integraciones del modelo.

Paso 1: Configuración de Langchain

Primero, debes instalar el paquete de Langchain. Estamos utilizando el sistema operativo Windows. Ejecuta el siguiente comando en tu terminal para instalarlo:

pip install langchain

Paso 2: Importar Langchain y otros módulos necesarios

A continuación, importa Langchain junto con otros módulos necesarios. Aquí, también importamos la biblioteca transformers, que se utiliza ampliamente en tareas de NLP.

import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Paso 3: Cargar modelo pre-entrenado

Open AI

Los modelos de OpenAI se pueden integrar convenientemente con la biblioteca LangChain o la biblioteca cliente de Python de OpenAI. En particular, OpenAI proporciona una clase Embedding para modelos de incrustación de texto. Dos modelos LLM clave son GPT-3.5 y GPT-4, que difieren principalmente en la longitud de los tokens. La tarificación para cada modelo se puede encontrar en el sitio web de OpenAI. Si bien existen modelos más sofisticados como GPT-4-32K que tienen una mayor aceptación de tokens, su disponibilidad a través de la API no siempre está garantizada.

Para acceder a estos modelos se requiere una clave de API de OpenAI. Esto se puede hacer creando una cuenta en la plataforma de OpenAI, configurando la información de facturación y generando una nueva clave secreta.

import os
os.environ["OPENAI_API_KEY"] = 'tu-token-de-openai'

Después de crear la clave correctamente, puedes configurarla como una variable de entorno (OPENAI_API_KEY) o pasarla como un parámetro durante la instanciación de clase para las llamadas de OpenAI.

Considera un script de LangChain para mostrar la interacción con los modelos de OpenAI:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# El LLM toma un prompt como entrada y devuelve una completación
prompt = "quién es el presidente de los Estados Unidos de América?"
completion = llm(prompt)

El presidente actual de los Estados Unidos de América es Joe Biden.

En este ejemplo, se inicializa un agente para realizar cálculos. El agente toma una entrada, una tarea simple de suma, la procesa utilizando el modelo de OpenAI proporcionado y devuelve el resultado.

Hugging Face

Hugging Face es una biblioteca Python de Transformers GRATUITA, compatible con PyTorch, TensorFlow y JAX, e incluye implementaciones de modelos como BERT, T5, etc.

Hugging Face también ofrece el Hugging Face Hub, una plataforma para alojar repositorios de código, modelos de aprendizaje automático, conjuntos de datos y aplicaciones web.

Para utilizar Hugging Face como proveedor de tus modelos, necesitarás una cuenta y claves de API, que se pueden obtener en su sitio web. El token se puede hacer disponible en tu entorno como HUGGINGFACEHUB_API_TOKEN.

Ten en cuenta el siguiente fragmento de código Python que utiliza un modelo de código abierto desarrollado por Google, el modelo Flan-T5-XXL:

from langchain.llms import HuggingFaceHub
llm = HuggingFaceHub(model_kwargs={"temperature": 0.5, "max_length": 64},repo_id="google/flan-t5-xxl")
prompt = "¿En qué país se encuentra Tokio?"
completion = llm(prompt)
print(completion)

Este script toma una pregunta como entrada y devuelve una respuesta, mostrando el conocimiento y las capacidades de predicción del modelo.

Paso 4: Ingeniería básica de la frase de entrada

Para empezar, generaremos una frase de entrada simple y veremos cómo responde el modelo.

prompt = 'Traduce el siguiente texto en inglés al francés: "{0}"'
input_text = 'Hola, ¿cómo estás?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')
generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

En el fragmento de código anterior, proporcionamos una frase de entrada para traducir texto en inglés al francés. El modelo de lenguaje intenta traducir el texto dado en función de la frase de entrada.

Paso 5: Ingeniería avanzada de la frase de entrada

Aunque el enfoque anterior funciona bien, no aprovecha al máximo el poder de la ingeniería de frases de entrada. Mejorémoslo introduciendo algunas estructuras de frases de entrada más complejas.

prompt = 'Como traductor de francés altamente competente, traduce el siguiente texto en inglés al francés: "{0}"'
input_text = 'Hola, ¿cómo estás?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')
generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

En este fragmento de código, modificamos la frase de entrada para sugerir que la traducción la realiza un ‘traductor de francés altamente competente’. El cambio en la frase de entrada puede mejorar las traducciones, ya que el modelo ahora asume una personalidad de experto.

Construyendo un sistema de preguntas y respuestas basado en literatura académica con LangChain

Construiremos un sistema de preguntas y respuestas basado en literatura académica utilizando LangChain que puede responder preguntas sobre artículos académicos recientemente publicados.

En primer lugar, para configurar nuestro entorno, instalamos las dependencias necesarias.

pip install langchain arxiv openai transformers faiss-cpu

Después de la instalación, creamos un nuevo cuaderno de Python e importamos las bibliotecas necesarias:

from langchain.llms import OpenAI
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
from langchain.docstore.document import Document
import arxiv

El núcleo de nuestro sistema de preguntas y respuestas es la capacidad de obtener documentos académicos relevantes relacionados con un determinado campo, aquí consideramos el Procesamiento del Lenguaje Natural (NLP), utilizando la base de datos académica arXiv. Para realizar esto, definimos una función get_arxiv_data(max_results=10). Esta función recopila los resúmenes de los artículos de investigación más recientes de NLP de arXiv y los encapsula en objetos de documento de LangChain, utilizando el resumen como contenido y el identificador de entrada único como fuente.

Utilizaremos la API de arXiv para obtener artículos recientes relacionados con NLP:

def get_arxiv_data(max_results=10):
    search = arxiv.Search(
        query="NLP",
        max_results=max_results,
        sort_by=arxiv.SortCriterion.SubmittedDate,
    )
   
    documents = []
   
    for result in search.results():
        documents.append(Document(
            page_content=result.summary,
            metadata={"source": result.entry_id},
        ))
    return documents

Esta función recupera los resúmenes de los artículos de investigación más recientes de NLP de arXiv y los convierte en objetos de documento de LangChain. Utilizamos el resumen del artículo y su identificador de entrada único (URL del artículo) como contenido y fuente, respectivamente.

def print_answer(question):
    print(
        chain(
            {
                "input_documents": sources,
                "question": question,
            },
            return_only_outputs=True,
        )["output_text"]
    )                 

Definamos nuestro corpus y configuremos LangChain:

sources = obtener_datos_arxiv(2)
chain = cargar_cadena_qa_con_fuentes(OpenAI(temperatura=0))

Con nuestro sistema académico de preguntas y respuestas listo, podemos probarlo haciendo una pregunta:

imprimir_respuesta("¿Cuáles son los avances recientes en NLP?")

La salida será la respuesta a tu pregunta, citando las fuentes de las cuales se extrajo la información. Por ejemplo:

Los avances recientes en NLP incluyen modelos de seguimiento de instrucciones con recuperador y un nuevo marco computacional para resolver problemas de flujo de potencia óptimo en corriente alterna (ACOPF) utilizando unidades de procesamiento gráfico (GPUs).
FUENTES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Puedes cambiar fácilmente de modelos o modificar el sistema según tus necesidades. Por ejemplo, aquí cambiamos a GPT-4, lo cual nos da una respuesta mucho mejor y más detallada.

sources = obtener_datos_arxiv(2)
chain = cargar_cadena_qa_con_fuentes(OpenAI(nombre_modelo="gpt-4", temperatura=0))

Los avances recientes en Procesamiento de Lenguaje Natural (NLP) incluyen el desarrollo de modelos de seguimiento de instrucciones con recuperador para tareas de búsqueda de información, como preguntas y respuestas (QA). Estos modelos pueden adaptarse a varios dominios de información y tareas sin necesidad de ajustes adicionales. Sin embargo, a menudo tienen dificultades para ceñirse al conocimiento proporcionado y pueden generar respuestas falsas. Otro avance es la introducción de un marco computacional para resolver problemas de flujo de potencia óptimo en corriente alterna (ACOPF) utilizando unidades de procesamiento gráfico (GPUs). Este enfoque utiliza una abstracción de programas no lineales (NLP) como instrucción única y datos múltiples (SIMD) y emplea un método de punto interior en espacio condensado (IPM) con una estrategia de relajación de desigualdades. Esta estrategia permite la factorización de la matriz KKT sin pivoteo numérico, lo cual previamente dificultaba la paralelización del algoritmo IPM.
FUENTES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Un token en GPT-4 puede tener desde un solo carácter hasta una palabra completa. Por ejemplo, GPT-4-32K puede procesar hasta 32.000 tokens en una sola ejecución, mientras que GPT-4-8K y GPT-3.5-turbo admiten 8.000 y 4.000 tokens respectivamente. Sin embargo, es importante tener en cuenta que cada interacción con estos modelos tiene un costo que es directamente proporcional al número de tokens procesados, ya sea de entrada o de salida.

En el contexto de nuestro sistema de preguntas y respuestas, si un fragmento de literatura académica supera el límite máximo de tokens, el sistema no podrá procesarlo en su totalidad, lo cual afectará la calidad y la integridad de las respuestas. Para solucionar este problema, el texto se puede dividir en partes más pequeñas que cumplan con el límite de tokens.

FAISS (Búsqueda de Similitud de IA de Facebook) ayuda a encontrar rápidamente los fragmentos de texto más relevantes relacionados con la consulta del usuario. Crea una representación vectorial de cada fragmento de texto y utiliza estos vectores para identificar y recuperar los fragmentos más similares a la representación vectorial de una pregunta dada.

Es importante recordar que incluso con el uso de herramientas como FAISS, la necesidad de dividir el texto en fragmentos más pequeños debido a limitaciones de tokens a veces puede llevar a la pérdida de contexto, lo cual afecta la calidad de las respuestas. Por lo tanto, la gestión cuidadosa y la optimización del uso de tokens son cruciales al trabajar con estos modelos de lenguaje grandes.

pip install faiss-cpu langchain CharacterTextSplitter

Después de asegurarte de que se hayan instalado las bibliotecas mencionadas anteriormente, ejecuta:

from langchain.embeddings.openai import OpenAIEmbeddings 
from langchain.vectorstores.faiss import FAISS 
from langchain.text_splitter import CharacterTextSplitter 
documents = obtener_datos_arxiv(max_resultados=10) # Ahora podemos agregar más datos
document_chunks = []
splitter = CharacterTextSplitter(separador=" ", tamano_fragmento=1024, superposicion_fragmentos=0)
for documento in documents:
    for fragmento in splitter.dividir_texto(documento.contenido_pagina):
        document_chunks.append(Documento(contenido_pagina=fragmento, metadatos=documento.metadatos))
search_index = FAISS.desde_documentos(document_chunks, OpenAIEmbeddings())
chain = cargar_cadena_qa_con_fuentes(OpenAI(temperatura=0))
def imprimir_respuesta(pregunta):
    print(
        chain(
            {
                "documentos_entrada": search_index.busqueda_similitud(pregunta, k=4),
                "pregunta": pregunta,
            },
            solo_salidas=True,
        )["texto_salida"]
    )

Con el código completo, ahora tenemos una herramienta poderosa para consultar la última literatura académica en el campo de NLP.

Los avances recientes en NLP incluyen el uso de redes neuronales profundas (DNN) para el análisis automático de texto y tareas de procesamiento de lenguaje natural (NLP) como la corrección ortográfica, detección de idioma, extracción de entidades, detección de autores, respuesta a preguntas y otras tareas.
FUENTES: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1 

Conclusión

La integración de Modelos de Lenguaje Grandes (LLMs) en aplicaciones ha acelerado la adopción en varios dominios, incluyendo la traducción de idiomas, análisis de sentimientos y recuperación de información. La ingeniería de comandos es una herramienta poderosa para maximizar el potencial de estos modelos, y Langchain lidera el camino en la simplificación de esta tarea compleja. Su interfaz estandarizada, plantillas de comandos flexibles, integración robusta de modelos y el uso innovador de agentes y cadenas garantizan resultados óptimos para el rendimiento de los LLMs.

Sin embargo, a pesar de estos avances, hay algunos consejos a tener en cuenta. Al utilizar Langchain, es esencial comprender que la calidad de la salida depende en gran medida de la redacción del comando. Experimentar con diferentes estilos y estructuras de comandos puede producir resultados mejorados. Además, recuerde que si bien Langchain admite una variedad de modelos de lenguaje, cada uno tiene sus fortalezas y debilidades. Elegir el adecuado para su tarea específica es crucial. Por último, es importante recordar que el uso de estos modelos conlleva consideraciones de costo, ya que el procesamiento de tokens influye directamente en el costo de las interacciones.

Como se muestra en la guía paso a paso, Langchain puede impulsar aplicaciones robustas, como el sistema de Preguntas y Respuestas de la Literatura Académica. Con una comunidad de usuarios en crecimiento y una presencia cada vez más destacada en el panorama de código abierto, Langchain promete ser una herramienta fundamental para aprovechar todo el potencial de los LLMs como GPT-4.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!