Curso de Agentes AI
Curso de Agentes AI

Fundamentos de los Agentes Inteligentes y LangChain

1

Introducción a LangChain

2

Agiliza procesos usando Agentes AI

3

Agentes inteligentes de LangChain

4

Instalación y configuración de LangChain

Quiz: Fundamentos de los Agentes Inteligentes y LangChain

Chat Models y Prompt templates

5

Chat Messages con OpenAI

6

Introducción a los modelos de chat

7

Output parsers

8

Prompt templates en LangChain

9

Tipos de ChatTemplates: Few-Shot Prompting

Quiz: Chat Models y Prompt templates

Cadenas en LangChain

10

Introducción a Chains y LCEL

11

Chat con historial

12

Integración de cadena: Runnable y OutputParser

13

Chat Memory

14

Implementación de memoria en cadenas

Quiz: Cadenas en LangChain

Carga de documentos en LangChain

15

Cargar HTML y Directorio con LangChain

16

Carga de PDF y CSV con LangChain

17

Text Splitters

Quiz: Carga de documentos en LangChain

Retrieval-augmented generation (RAG)

18

VectorStore: Chroma

19

Introducción a Embeddings

20

Vectorstore: Pinecone

21

Chatbot RAG: carga de documentos a Vectorstore

22

Chatbot RAG: prompt templates, cadenas y memoria

Quiz: Retrieval-augmented generation (RAG)

Agentes en LangChain

23

Construcción de agentes en LangChain

24

LangChain Tools

25

Construcción de agentes con memoria

Quiz: Agentes en LangChain

Ecosistema de LangChain

26

Ecosistema de LangChain

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Curso de Agentes AI

Curso de Agentes AI

Carli Code

Carli Code

Integración de cadena: Runnable y OutputParser

12/26
Recursos

Hemos explorado tres herramientas clave de LangChain que permiten construir flujos de trabajo más eficientes y escalables: Runnable, OutputParser, y Streaming. Estas herramientas ofrecen la capacidad de ejecutar tareas en secuencia o en paralelo, estructurar las respuestas en formatos como JSON, y ofrecer respuestas en tiempo real a los usuarios. Esto es esencial para desarrollar agentes inteligentes como chatbots avanzados, capaces de procesar grandes volúmenes de datos de manera rápida y organizada.

1. Runnable: Ejecución en Secuencia o Paralelo

Runnable es una herramienta que te permite encadenar y ejecutar tareas de forma secuencial o en paralelo. Esto resulta útil cuando tienes varias operaciones que deseas realizar de manera conjunta o cuando una secuencia de procesos depende de los resultados previos.

  • Ejecución Secuencial: Permite que los procesos se ejecuten uno tras otro. Por ejemplo, el resultado de una operación matemática puede alimentar a la siguiente operación en la secuencia.
  • Ejecución en Paralelo: En este modo, múltiples procesos pueden ejecutarse al mismo tiempo, lo que optimiza el tiempo de respuesta en tareas que no dependen entre sí.

En el ejemplo de la clase, vimos cómo ejecutar una serie de funciones lambda donde el resultado de una función alimenta a la siguiente. Esta cadena de procesos es flexible y te permite manejar datos de manera eficiente.

2. OutputParser: Convertir Salidas en Datos Estructurados

OutputParser es una herramienta que convierte las respuestas generadas por el modelo en datos estructurados. Esto es particularmente útil cuando necesitas una salida en un formato específico, como JSON, en lugar de una simple cadena de texto.

  • JSON OutputParser: Este parser convierte la respuesta del modelo en un formato JSON, lo que facilita su uso en aplicaciones que requieren respuestas estructuradas y organizadas.
  • Aplicación en Chatbots: Al crear agentes que gestionen grandes cantidades de datos o necesiten respuestas estructuradas, como resúmenes, informes o análisis, OutputParser permite que las respuestas sean fácilmente procesables por otros sistemas.

En el ejemplo de la clase, el JSON OutputParser se utilizó para devolver la respuesta del modelo en formato JSON, lo que permite que las respuestas sean más fáciles de interpretar y reutilizar.

3. Streaming: Resultados en Tiempo Real

Streaming permite que las respuestas generadas por el modelo se transmitan en tiempo real, lo que es útil en escenarios donde los usuarios no quieren esperar a que se genere una respuesta completa. Esto es similar a cómo funciona ChatGPT, donde ves la respuesta construirse a medida que se genera.

  • Experiencia de Usuario Mejorada: En lugar de esperar a que el modelo genere la respuesta completa, el usuario ve cómo se desarrolla la respuesta en tiempo real, lo que ofrece una experiencia más interactiva y satisfactoria.
  • Aplicaciones en Chatbots: Esta técnica es especialmente útil en chatbots donde la interacción fluida es clave, y los usuarios quieren ver respuestas rápidas y en tiempo real.

En la clase, se utilizó Streaming para enviar la respuesta del modelo en fragmentos, lo que permite que el texto se genere de manera progresiva y el usuario vea cómo se construye la respuesta sin tener que esperar demasiado.

4. Integración de Runnable, OutputParser y Streaming

La combinación de estas herramientas permite construir agentes que no solo ejecuten tareas de manera eficiente, sino que también entreguen respuestas precisas y en tiempo real. Un agente que utiliza Runnable puede manejar múltiples tareas de manera simultánea o secuencial, y con OutputParser puedes asegurarte de que las respuestas del modelo tengan el formato adecuado. Streaming, por su parte, mejora la experiencia del usuario al ofrecer resultados inmediatos.

  • Ejemplo de Aplicación: Un chatbot financiero podría utilizar Runnable para procesar consultas de varios usuarios en paralelo, aplicar un OutputParser para entregar informes financieros en formato JSON, y utilizar Streaming para mostrar actualizaciones en tiempo real sobre los precios de las acciones.

5. Aplicaciones Prácticas

Con estas herramientas, puedes crear aplicaciones como:

  • Asistentes Virtuales: Que manejan múltiples consultas simultáneamente, proporcionando respuestas personalizadas y organizadas en tiempo real.
  • Sistemas de Atención al Cliente: Que pueden estructurar respuestas y generar informes de manera instantánea, mejorando la eficiencia en la resolución de problemas.
  • Plataformas Educativas: Que permiten a los estudiantes obtener respuestas en tiempo real mientras realizan tareas y reciben retroalimentación instantánea.

6. Conclusión

En esta clase, vimos cómo integrar Runnable, OutputParser, y Streaming para construir aplicaciones más potentes y eficientes utilizando LangChain. Estas herramientas ofrecen una forma flexible y escalable de gestionar tareas, estructurar respuestas y mejorar la experiencia del usuario con resultados en tiempo real.

El reto que te dejo es que explores cómo combinar estas herramientas en un proyecto personal. Intenta construir una cadena que utilice Runnable para ejecutar múltiples tareas, estructure las salidas en formato JSON con OutputParser, y utilice Streaming para mostrar las respuestas en tiempo real a los usuarios. ¡Déjame saber en los comentarios cómo te fue!

Aportes 6

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Juan Pablo Paillet

Juan Pablo Paillet

hace 6 meses
![](https://www.plantuml.com/plantuml/png/XPJ1RlCs3CVlVWhYsoreF_GRXdrh3qFN8Xam36knj0_0seohLY8zIWgM3dkadNRhDIysIOvZnq2nIsj9Vv7_7qdbsWVK49sj_AlX3XKTADK1kRK4VrK003TOlxOgaPjRiQBmpV9YzNNrKpbR2OT-zyacMQyNRKWFsekBhvVVtnorQ_D6yEMxSHrsbk19R5FzNKqyi8GFqw--h7vONlvlghcjCVstEHVMGHGUVKGrKbKZzATVq__w6Gt3WuZrdm0zZ7kzgOdyzyYCJvQAJW-BkUWkXYu6k4Vrf4KfPQVVcAlNGGcTuROe_R3AjW-6uVpynucfArZoTlyFGi2azLKr7cNXu2hhNgYEOH02CVYqGLmR185SV4jMgk56kJwrcaBS2cyDQI3mQ4s3ESX6r64G-6LzzrirrUS08q6wVRT9e0HAlelaGxaT3BbE88biLPNMgscV0yXcMj35OYZrOd6LrkTmJ-fCKXFNs12Z3bX_H88KFkq1zS3gIq_cmCH7viybPAgFwwnSmMCwKQd9Iubck5Pon04XCl3-tP4AxC16QWMiW8iscCwQ6ZzNn4sPu0ECfKrXcTQby9nCnG0rbjUY7-laeI4BJj9VcLJSzrG-QAn3L6p4GoskxmG81Fep27GMUG3qi7yFnXPk46sHpHigD1Zwgvsbb_JL4bCVhXE5O-eHRjQfiSa5xJZ20zROzsX3ZZjh_DaX8pTIa4Rmt8SsBSqMSmEeTquMOdaB1wwrSSQY0aAz_zS9U3e4XCXuEcu_tp_Cad_Kil695QZPByE0jYmkdqar4HCNo_raCjHAsLIRZNl0BV9RXY-8PKhBZ253cz6JP2is3nTJRdZfIlbmo3JfLuEm0zgOEkUZlWB3wm0wUUDdS39carcP3TXPCRM3O-i6Yc9qh3Ti2S5EQrge5VrOz6b1hzDdTBRw3m00) 1. **Runnable**: * Ejecuta tareas de manera secuencial o en paralelo. * Permite organizar el flujo de trabajo de procesos conectados que se invocan uno tras otro o en paralelo para mejorar la eficiencia. * **Ejemplo**: Sumar 1 a un valor y luego multiplicar por 2, pasando el resultado de una tarea a la siguiente. 2. **Output Parser**: * Convierte las respuestas del modelo en datos estructurados, como JSON o texto organizado, lo que es útil para obtener datos claros y procesables. * Facilita la interpretación y almacenamiento de los resultados generados por el modelo. 3. **Streaming**: * Permite ver las respuestas de manera progresiva en tiempo real. * Ideal para reducir la espera del usuario y mejorar la experiencia interactiva, como ocurre en los sistemas de generación de texto en tiempo real como GPT. 4. **Langchain Tools**: * Integra las tres herramientas clave (Runnable, Output Parser y Streaming) para construir agentes más eficientes y escalables que puedan procesar grandes volúmenes de datos y generar respuestas rápidas y estructuradas.
Fabián Rodriguez Peña

Fabián Rodriguez Peña

hace 4 meses
Explicas el astream pero no explicas para que sirve cada uno de sus parámetros. Se quedan por fuera muchas dudas.
Cesar Augusto Vega Lizarazo

Cesar Augusto Vega Lizarazo

hace 6 meses
Existe conflicto entre vrsiones de openai y langchain, realice tres pruebas pero la mejor fue con la ultma version: Name: openai, Version: 1.51.2 y Name: langchain Version: 0.3.3. ```python #import os from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder from langchain_openai import ChatOpenAI from langchain_core.messages import AIMessage, HumanMessage, SystemMessage # Configura tu API key de OpenAI #os.environ["OPENAI_API_KEY"] = "tu-api-key-aquí" # Inicializa el modelo de chat #chat = ChatOpenAI(model_name="gpt-3.5-turbo-16k", temperature=0.7) chat = ChatOpenAI(temperature=0.7) # Define el prompt del sistema system_prompt = SystemMessage(content="""Eres un asistente amigable y útil. Tu tarea es mantener una conversación agradable y proporcionar información útil al usuario. Sé amable, paciente y siempre dispuesto a ayudar.""") # Crea un prompt de chat que incluye el historial de la conversación prompt = ChatPromptTemplate.from_messages([ system_prompt, MessagesPlaceholder(variable_name="chat_history"), ("human", "{input}") ]) # Inicializa el historial de chat chat_history = [] print("¡Hola! Soy tu asistente virtual. ¿En qué puedo ayudarte hoy? (Escribe 'salir' para terminar)") while True: # Obtén la entrada del usuario user_input = input("Tú: ") # Verifica si el usuario quiere salir if user_input.lower() == 'salir': print("Asistente: ¡Hasta luego! Fue un placer ayudarte.") break # Genera la respuesta usando el modelo de chat messages = prompt.format_messages( chat_history=chat_history, input=user_input ) response = chat.invoke(messages) # Imprime la respuesta del asistente print("Asistente:", response.content) # Actualiza el historial de chat chat_history.append(HumanMessage(content=user_input)) chat_history.append(AIMessage(content=response.content)) # Limita el historial de chat a las últimas 5 interacciones para evitar tokens excesivos if len(chat_history) > 10: chat_history = chat_history[-10:] ```![]()![]()![](file:///F:/Cursos/2024/Agentes%20IA/Demo_Chat_Converssacional3.png)
Yulieth Angélica Vega Araujo

Yulieth Angélica Vega Araujo

hace 2 meses
```js import nest_asyncio import asyncio import time from langchain.memory import ConversationBufferMemory from langchain_openai import ChatOpenAI from langchain.prompts import ChatPromptTemplate from langchain_core.output_parsers import JsonOutputParser nest_asyncio.apply() memory = ConversationBufferMemory() model = ChatOpenAI(model="gpt-4o", streaming=True) parser = JsonOutputParser() prompt = ChatPromptTemplate.from_messages([ ("system", "Eres un asistente conversacional que recuerda el historial del usuario y responde en JSON."), ("human", "{history}\nUsuario: {query}") ]) chain = prompt | model | parser async def chat(): print("\n🤖 ChatBot en vivo (escribe 'salir' para terminar)\n") while True: user_input = input("Tú: ") if user_input.lower() == "salir": print("\n🤖 ChatBot: ¡Hasta luego! 👋") break history = memory.load_memory_variables({}).get("history", "") query_with_history = f"{history}\nUsuario: {user_input}" # ✅ Convertir a string print("🤖 ChatBot: ", end="", flush=True) response_text = "" async for chunk in model.astream(query_with_history): # ✅ Ahora enviamos un string print(chunk.content, end="", flush=True) response_text += chunk.content time.sleep(0.1) print("\n") memory.save_context({"query": user_input}, {"response": response_text}) # ✅ Guardamos historial await chat() ```
Eduardo Guzmán

Eduardo Guzmán

hace 3 meses
siento que el tema es manejar todas estas funciones de manera eficiente para que no consuman tantos tokens. o usar un llm open source como llama
Baldan
La **integración de cadenas** en contextos de frameworks o bibliotecas de procesamiento de lenguaje natural, como LangChain, se refiere a la construcción y ejecución de flujos de trabajo mediante la concatenación de tareas o pasos que se ejecutan secuencialmente. En LangChain, este concepto se utiliza para orquestar varias acciones que manipulan el texto o las consultas a medida que se procesan en la cadena. Aquí entran en juego componentes como **Runnable** y **OutputParser**.