Cuando trabajas con LangChain, las cadenas fundacionales son los bloques mínimos que puedes combinar para construir flujos más complejos. Aquí aprenderás a unir una TransformChain con una LLMChain dentro de una SequentialChain, ideal si necesitas limpiar texto antes de pasarlo a un modelo de lenguaje.
Qué son las cadenas fundacionales y por qué encadenarlas
Una cadena fundacional es un eslabón individual que procesa texto de una forma muy concreta. La gracia está en que puedes unir varios eslabones para que el output de uno alimente al siguiente, como piezas de Lego. De hecho, la lógica recuerda mucho a cómo armas un modelo en PyTorch.
En el ejemplo que vamos a recorrer hay dos cadenas:
Una TransformChain que limpia el texto de emojis y URLs.
Una LLMChain que parafrasea el texto limpio con un estilo regional.
¿Qué es una TransformChain? Es una cadena que aplica una función de Python pura sobre el texto de entrada. No usa modelos de IA, solo transforma datos según la lógica que tú definas.
Cómo construir una TransformChain para limpiar texto
El primer paso es crear una función de Python que reciba un diccionario y devuelva otro diccionario. Esa es toda la magia: nada de inteligencia artificial todavía, solo regex aplicado con la librería re.
Función limpiar_texto paso a paso
La función toma la llave texto del diccionario de entrada y aplica dos transformaciones [01:20]:
Sustituye emojis y símbolos fuera de un rango amplio de unicode por un espacio en blanco.
Elimina cualquier patrón que parezca URL, como https o www.
Al final, retorna un diccionario con la llave texto_limpio que contiene el resultado procesado. Esto es clave porque la TransformChain se conecta con el resto del flujo justamente por esos nombres de llaves.
Instanciar la TransformChain
Importas TransformChain desde la librería chains de LangChain y creas el objeto cadena_que_limpia indicando tres argumentos:
input_variables: lista con texto.
output_variables: lista con texto_limpio.
transform: la función limpiar_texto.
Cuando la corres con un prompt como "Chequeen esta página" más un URL y un emoji, la respuesta llega casi instantánea porque no hay modelo de por medio, solo Python ejecutando regex [03:45].
Cómo unir TransformChain y LLMChain en una SequentialChain
La cadena que limpia por sí sola no aporta tanto. Lo interesante aparece cuando la conectas con una LLMChain que use un modelo de OpenAI para parafrasear.
Plantilla con dos variables de entrada
Creas un PromptTemplate con dos input_variables: texto_limpio y estilo. La instrucción dentro del prompt es "parafrasea esto", y el estilo puede ser, por ejemplo, una persona informal de Perú, México o Chile.
Luego instancias LLMChain pasando:
El modelo llm, en este caso un GPT-3.5 turbo de OpenAI.
El prompt recién creado.
El output_key igual a texto_final.
¿Por qué los nombres de las llaves importan tanto? Porque la SequentialChain conecta cadenas usando esos nombres. Si una cadena retorna texto_limpio, la siguiente debe esperar exactamente esa variable como entrada.
Ensamblar la SequentialChain
Importas SequentialChain desde chains y la instancias con [07:30]:
chains: lista con cadena_que_limpia y cadena_que_cambia_estilo.
input_variables: texto y estilo.
output_variables: texto_final.
Fíjate en el flujo: el usuario ingresa texto y estilo. La primera cadena consume texto y produce texto_limpio. La segunda recibe texto_limpio (de la cadena anterior) más estilo (del usuario) y produce texto_final.
Qué resultado entrega el flujo completo
Al correr la SequentialChain con un texto sobre la ciudad de Monterrey, México, lleno de emojis, banderitas y URLs como visitamonterrey.com, junto con el estilo "una persona de Perú", el resultado final llega sin emojis ni links.
Un fragmento del output: "Oye, Monterrey es una ciudad superchévere, tiene unas montañas impresionantes". Quien sea de Perú reconocerá ese tono, bacán.
¿Qué diferencia hay entre cadenas fundacionales y cadenas de utilidad? Las fundacionales son los bloques básicos como TransformChain o LLMChain. Las de utilidad son combinaciones con un propósito concreto, como limpiar y reformular texto.
Reto: agrega una tercera cadena al flujo
Amplía la SequentialChain con un tercer eslabón. El orden propuesto:
Limpia el texto de entrada.
Genera un texto nuevo a partir del limpio.
Crea un resumen del texto generado.
Ingresa un texto largo para que el resumen tenga sentido y comparte tu resultado en los comentarios. ¿Qué estilo regional probarás primero?
Agregué solo la parte de la nueva cadena que resume y la definición de la cadena sequencial
## Plantilla para la cadena de resumen
## Decidí incluirle de nuevo el estilo para que mantenga la forma de hablar para generar el resumen
plantilla_resumen ="""Resumir texto:{texto_final}En el estilo de una persona informal de {estilo}resumen:"""
# Definición del template con sus variables de entrada {texto_final} que viene de la cadena anterior de parafraseo
prompt_resumen =PromptTemplate( template= plantilla_resumen, input_variables=["texto_final","estilo"])## Instancia de la cadena que resumne
cadena_que_resume =LLMChain( llm=llm_gpt3_5, prompt=prompt_resumen, output_key='texto_resumido')from langchain.chainsimportSequentialChain# Cadena secuencial agregando la cadena que resume
cadena_secuencial =SequentialChain( chains=[cadena_que_limpia, cadena_que_cambia_estilo,cadena_que_resume], input_variables=["texto","estilo"], output_variables=["texto_resumido"])
Me dió mucha pereza escribir el texto, así que le pedí al gpt-35-turbo que lo creara por mi especificando que quería urls y emojis para probar que funcionara la cadena de transformación:
👍💡
Por cierto a Octubre del 24 la nueva manera de llamar las cadenas son las siguientes:
Transformchain se mantiene igual
cadena_que_limpia = TransformChain(
input_variables=['texto'],
output_variables=['texto_limpio'],
transform=limpiar_texto
)
LLMChain y Sequential Chains van de la siguiente manera:
Para crear una Cadena secuencial en Langchain >= 1.0, Debemos usar LCEL (Langchain Expression Language).
El siguiente ejemplo crea una cadena secuancial con los siguientes pasos:
Limpia el texto
Resume el text
parafrasea el texto a un estilo dinamico que el usuario desee.
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.runnables import RunnableLambda, RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)# STEP 1# standalone chain to clean textclean_text_chain = RunnableLambda(limpiar_texto)# STEP 2# Add prompt to summarize the clean textsummarize_text_prompt = ChatPromptTemplate.from_template("""Crea un resumen comprensivo del siguiente texto:
{clean_text}
Resumen:""")# chain that summarizessummarize_text_chain = summarize_text_prompt | llm | StrOutputParser()# STEP 3# Add a prompt to change text style to responsechange_text_style_prompt = ChatPromptTemplate.from_template("""Parafrasea este texto:
{summarized_text}
En el estilo de una persona informal de {style}.
Parafraseado: """)# Chain that change text stylechange_text_style_chain = change_text_style_prompt | llm | StrOutputParser()# invoke the chain# STEP 4:# Add Sequential Chain thar runs all utility chains.transform_text_chain =(# 1. prepares inputs for the cleant text chain RunnableLambda(lambda data:{"text": data["text"],"style": data["style"]})# 2. run clean text chain it will returns dict with (text, style) keys| clean_text_chain
# 3. run the chain to summarize and preserves the values of style| RunnableLambda(lambda data:{"summarized_text": summarize_text_chain.invoke({"clean_text": data["clean_text"]}),"style": data["style"]})# 4. prepare input for the change text style| RunnableLambda(lambda data:{"summarized_text": data["summarized_text"],"style": data["style"]})# 5. run the chain to change text style| change_text_style_chain
| StrOutputParser())
Para ejecutarlo:
text_style ="Brasilero"# Change this value to get diferent stylesinput_data ={"text": texto_entrada,"style": text_style
}transform_text_chain.invoke(input_data)
La function limpiar texto va a retornar un dict que incluye las keys text y style. esto nos permite preservar y hacer dinamico el estilo que el usuario quiere en el response de la cadena.
import re
deflimpiar_texto(entradas:dict)->dict: texto = entradas["text"]# Eliminamos los emojis utilizando un amplio rango unicode# Ten en cuenta que esto podría potencialmente eliminar algunos caracteres válidos que no son en inglés patron_emoji = re.compile("[""\U0001F600-\U0001F64F"# emoticonos"\U0001F300-\U0001F5FF"# símbolos y pictogramas"\U0001F680-\U0001F6FF"# símbolos de transporte y mapas"\U0001F1E0-\U0001F1FF"# banderas (iOS)"\U00002702-\U000027B0""\U000024C2-\U0001F251""]+", flags=re.UNICODE,) texto = patron_emoji.sub(r'', texto)# Removemos las URLs patron_url = re.compile(r'https?://\S+|www\.\S+') texto = patron_url.sub(r'', texto)return{"clean_text": texto,"style": entradas["style"]}
Me costó un poco porque a este punto creí que debía usar una cadena de transformación, pero realmente requerimos usar un LLMChain con un nuevo template.
Antes de todo, cambié el output de la chain de estilo a "to_sum_text" y creé el template y el PromptTemplate.
summary_template ="""Resume este texto lo más posible:{to_sum_text}Resumiendo:"""
prompt_summary =PromptTemplate( input_variables=["to_sum_text"], template=summary_template
)
'final_text':'Monterrey es una ciudad increíble, famosa por sus montañas imponentes, su cultura norteña y su Museo de Arte Contemporáneo. También es conocida por los partidos de fútbol de los Rayados y los Tigres. ¡Monterrey te espera con los brazos abiertos!'
Notemos que el prompt final se deshizo de los espacios extraños que había generado el cleaner, por lo que indirectamente aplicó otra capa de limpieza.
Cumpliendo el reto
Invertí el orden, primero limpia, luego resume y finalmente cambia el estilo.
cadena_que_limpia =TransformChain( input_variables=["texto"], output_variables=["texto_limpio"], transform=fn_limpiar_texto
)
############################################
# Cadena que resume
summarize_prompt ="""Resumir el siente texto:{texto_limpio}Resumen:"""
summarize_chain =LLMChain( llm=llm_gpt3_5, prompt=PromptTemplate( input_variables=["texto_limpio"], template=summarize_prompt
), output_key="summary")
############################################
# Cadena que cambia de estilo
from langchain.chainsimportLLMChainfrom langchain importPromptTemplateplantilla ="""Parafrasea este texto:{summary}En el estilo de una persona informal de {estilo}.Parafraseado:"""
prompt =PromptTemplate( input_variables=["summary","estilo"], template=plantilla
)cadena_que_cambia_estilo =LLMChain( llm = llm_gpt3_5, prompt=prompt, output_key="texto_final")# Cadena secuencial
from langchain.chainsimportSequentialChaincadena_secuencial =SequentialChain( chains =[cadena_que_limpia, summarize_chain, cadena_que_cambia_estilo], input_variables=["texto","estilo"], output_variables=["texto_final"])
El texto de entrada:
texto_entrada ="""
Osaka es una ciudad vibrante y llena de vida en Japón 🏯🌸.Con su combinación
única de tradición y modernidad,Osaka cautiva a sus visitantes.Puedes explorar
el imponente castillo de Osaka, un verdadero símbolo histórico de la región 🏰🌳.Además, la deliciosa comida callejera en el distrito de Dotonbori te dejará con el
estómago lleno y una sonrisa en el rostro 😋🍣.La gente en Osaka es conocida por su amabilidad y hospitalidad, lo que hace que los
viajeros se sientan bienvenidos desde el momento en que llegan ✨👋.Si eres un
amante de las compras, la avenida Midosuji es el lugar perfecto para satisfacer tus
deseos de compras y moda 👗🛍️.Para obtener más información sobre los lugares para visitar en Osaka, puedes
consultar el sitio web oficial de turismo: https://www.osaka-info.jp/en/ 🌐📲.¡No puedes perderte la oportunidad de experimentar la energía única y la cultura
emocionante de Osaka!"""
cadena_secuencial({'texto': texto_entrada,'estilo':'Chile'})
El resultado:
'texto_final':'Osaka es una ciudad bacán y llena de vida en Japón, que mezcla la onda tradicional con la modernidad. Su castillo gigante y la comida rica en la calle en el barrio de Dotonbori son un must. La buena onda de la gente y la avenida Midosuji para ir de shopping son bien destacables. No te podís perder la oportunidad de vivir la energía y cultura emocionante de Osaka.'}
Código para 09/06/25
from langchain.chains import TransformChain
cadena_que_limpia = TransformChain( input_variables=["texto"], output_variables=["texto_limpio"], transform=limpiar_texto
)cadena_que_limpia.run('Chequen está página https://twitter.com/home 🙈')prompt = ChatPromptTemplate([("system","""Eres un asistente que parafrasea textos de manera informal, usando el estilo de una persona de {estilo}"""),("human","Parafrasea este texto: {texto_limpio} en el estilo de una persona informal de {estilo}")], input_variables=["texto_limpio","estilo"])cadena_cambia_estilo = prompt | llm_gpt3_5
cadena_sequencial = cadena_que_limpia | cadena_cambia_estilo
texto_entrada ="""
¡Monterrey es una ciudad impresionante! 🏙️
Es conocida por su impresionante paisaje de montañas ⛰️ y su vibrante cultura norteña.
¡No olvides visitar el famoso Museo de Arte Contemporáneo (MARCO)!
🖼️ Si eres fanático del fútbol, no puedes perderte un partido de los Rayados o de los Tigres. ⚽
Aquí te dejo algunos enlaces para que puedas conocer más sobre esta maravillosa ciudad:
https://visitamonterrey.com, https://museomarco.org, https://rayados.com, https://www.tigres.com.mx.
¡Monterrey te espera con los brazos abiertos! 😃🇲🇽
"""resultado = cadena_sequencial.invoke({"texto": texto_entrada,"estilo":"mexicano"})resultado.content
Dejo por aquí el patrón de emojis por si alguien no lo quiere transcribir o tomar del notebook.
emoji_pattern = re.compile("[""\U0001F600-\U0001F64F" #emotes
"\U0001F300-\U0001F5FF" #symbols and pictograms
"\U0001F680-\U0001F6FF" #transport and map symbols
"\U0001F1E0-\U0001F1FF"#flags(on iOS)"\U00002702-\U000027B0""\U000024C2-\U0001F251""]+", flags=re.UNICODE)
from langchain.chains.transform import TransformChainfrom langchain.chains.retrieval_qa.base import RetrievalQA
➡️ Secuencias (Secuencies)
ℹ️ Summary
Esta guía proporciona un caso de uso sobre Cadenas Secuenciales (Sequential Chain), sobre documentos combinados en cadenas, en un almacenamiento vectorial local.
.
🗂️ Background
Una LLMChain es una cadena simple que añade alguna funcionalidad alrededor de los modelos de lenguaje. La cual consiste en un PromptTemplate y un modelo de lenguaje (ya sea un LLM o un modelo de chat). Formatea el prompt template usando los valores de las claves de entrada proporcionadas (y también los valores de las claves de memoria, si están disponibles), pasa la cadena formateada al LLM y devuelve la salida del LLM.
.
Una secuencia es un tipo de Cadena Funcional (Functional Chain), que permiten conectar varias cadenas y componerlas en pipelines que ejecutan algún escenario específico. Existen dos tipos de cadenas secuenciales:
.
SimpleSequentialChain: La forma más simple de cadenas secuenciales, donde cada paso tiene una entrada/salida singular, y la salida de un paso es la entrada del siguiente.
SequentialChain: Una forma más general de cadenas secuenciales, que permite múltiples entradas/salidas.
.
En conjunto, permiten un túnel personalizado según los requerimientos de la aplicación.
.
Enlaces auxiliares:
Secuencias (Sequential)
LLM
.
🎯 Problem
Implementar una "Functional Chain" en LangChain utilizando TypeScript para implementar un flujo de tareas, por ejemplo, procesar y analizar datos textuales para proveer un formato preferido.
.
🚧 Solution
Una SimpleSequentialChain es una cadena que permite unir varias cadenas de una entrada y una salida en una sola cadena.
import { SimpleSequentialChain } from 'langchain/chains'
Dicha cadena, servirá para orquestar a los eslabones de cada proceso en conjunto. Por ejemplo, para obtener una entrada de QA y después darle formato según sea el requerimiento:
const actionitemsChain = new SimpleSequentialChain({
chains: [retrievalQAChain, actionItemsFormatChain],
})
En ella, obtenemos una cadena que es provista de un almacenamiento vectorial.
Así mismo, se combina mediante una cadena para proveer de un formato. Dicho formato, puede ser soportada por Zod, una herramienta para gestionar estructura de datos bajo un determinando tipo.
.
Por lo que empleamos una prompt personalizado en combinación de LLMChain.
const prompt = new PromptTemplate({
inputVariables: ['list'],
template: `
Given a numerical list with action items to be carried out by the team.
Improve the content of each action item.
{list}`,
})
const outParser = OutputFixingParser.fromLLM(
llm,
StructuredOutputParser.fromZodSchema(
z.array(
z.string()
.describe('Action item to be carried out by the team'),
).describe('Action items to be carried out by the team'),
),
)
const actionItemsFormatChain = new LLMChain({
llm,
prompt,
outputKey: 'records',
outputParser: outParser,
})
🍻 Discussion
Las secuencias son personalizables en LangChain. Donde el caso de uso, permitirán generar "Functional Chains" para permitirnos generar un flujo completo de procesamiento.
Cada eslabón, en una secuencia se tiene que pensar en un filtro permisivo para poder refinar nuestra salida de información.
import { z } from 'zod'
import { LLMChain, RetrievalQAChain, SimpleSequentialChain } from 'langchain/chains'
import { HNSWLib } from 'langchain/vectorstores/hnswlib'
import { OpenAIEmbeddings } from 'langchain/embeddings/openai'
import { OpenAI } from 'langchain/llms/openai'
import { StructuredOutputParser, OutputFixingParser } from 'langchain/output_parsers'
import { PromptTemplate } from 'langchain/prompts'
import { TextLoader } from 'langchain/document_loaders/fs/text'
const API_TOKEN = // 👈 Enter the API Token from OpenAI
const loader = new TextLoader('tmp/conversation.txt')
const docs = await loader.load()
const llm = new OpenAI({
maxTokens: -1,
modelName: 'gpt-4',
temperature: 0,
openAIApiKey: API_TOKEN,
})
const embeddings = new OpenAIEmbeddings({
openAIApiKey: API_TOKEN,
})
const vectorStore = await HNSWLib.fromDocuments(docs, embeddings)
const retrievalQAChain = RetrievalQAChain.fromLLM(
llm,
vectorStore.asRetriever({ k: 1 }),
)
const actionItemsFormatChain = new LLMChain({
llm,
prompt: new PromptTemplate({
inputVariables: ['list'],
template: `
Given a numerical list with action items to be carried out by the team.
Improve the content of each action item.
{list}`,
}),
outputKey: 'records',
outputParser: OutputFixingParser.fromLLM(
llm,
StructuredOutputParser.fromZodSchema(
z.array(
z.string()
.describe('Action item to be carried out by the team'),
).describe('Action items to be carried out by the team'),
),
),
})
const actionitemsChain = new SimpleSequentialChain({
chains: [retrievalQAChain, actionItemsFormatChain],
})
const response = await actionitemsChain.run(
'Given a conversation between employees, obtain the action items to be carried out by the team.',
)
console.log(response)
En esta clase veremos como funcionan las cadenas Foundatinoal y como podemos unir varias de ellas para llevar procesos
más complejos a través de cadenas secuenciales SequentialChain.
Primero, vamos a construir una función personalizada para limpiar nuestros textos de URLs y emojis. Luego, utilizaremos esta función para crear una cadena en la que introduciremos nuestro texto y esperamos obtener un texto limpio como salida.
Debemos tener en cuenta que la función que hemos creado recibe como entrada un diccionario. En este diccionario, vamos a indicar los elementos que serán procesados por la cadena que estamos creando. El resultado que obtendremos de la cadena será el texto limpio.
Esto es el principio fundamental de las cadenas fundacionales, nos proporcionan un marco para llevar a cabo una serie de transformaciones de manera ordenada y estructurada.
Partimos de los antecedentes que ya conocemos:
# Antecedentes 1: Cargar el API KEY de OpenAI como una variable de sistema.import os
from dotenv import load_dotenv
load_dotenv("../secret/keys.env")OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")os.environ['OPENAI_API_KEY']= OPENAI_API_KEY
# Antecedentes 2: Instanciar dos LLMs de OpenAI un GPT3.5 y un Davincifrom langchain.llms import OpenAI
llm_gpt3_5 = OpenAI( model_name="gpt-3.5-turbo", n=1, temperature=0.3)
Vamos a empezar creando una función de limpieza de datos. La misma es una función que recibe un diccionario con una llave texto
que contiene el texto a limpiar y devuelve otro diccionario con la llave texto_limpio, el texto ya normalizado.
deflimpiar_texto(entradas:dict)->dict: texto = entradas["texto"]# Eliminamos los emojis utilizando un amplio rango unicode# Ten en cuenta que esto podría potencialmente eliminar algunos caracteres válidos que no son en inglés patron_emoji = re.compile("[""\U0001F600-\U0001F64F"# emoticonos"\U0001F300-\U0001F5FF"# símbolos y pictogramas"\U0001F680-\U0001F6FF"# símbolos de transporte y mapas"\U0001F1E0-\U0001F1FF"# banderas (iOS)"\U00002702-\U000027B0""\U000024C2-\U0001F251""]+", flags=re.UNICODE,) texto = patron_emoji.sub(r'', texto)# Removemos las URLs patron_url = re.compile(r'https?://\S+|www\.\S+') texto = patron_url.sub(r'', texto)return{"texto_limpio": texto}
Con base en esta función de python podemos crear nuestro primer bloque de Cadena utilizando TransformChain:
from langchain.chains import TransformChain
cadena_que_limpia = TransformChain( input_variables=["texto"], output_variables=["texto_limpio"], transform=limpiar_texto
)clean = cadena_que_limpia.run('Chequen está página https://twitter.com/home 🙈')print(clean)
Respuesta esperada:
Chequen está página
Ahora vamos a crear un par de cadenas más y finalmente las vamos a unir todas para un flujo de información completa.
Empecemos con una cadena de parafraseo de texto:
from langchain import PromptTemplate
from langchain.chains import LLMChain
# Empezamos creando nuestro prompt template que recibe como parámetro un 'texto_limpio' (salida de de la cadena de limpieza)# y lo parafrasea con un estilo informa de una persona (estilo).plantilla_parafrasea ="""Parafrasea este texto:
{texto_limpio}
En el estilo de una persona informal de {estilo}.
Parafraseado: """# Dado que nuestro Template tiene 2 variables, debemos indicarlas en el parámetro `input_variablesprompt_parafraseo = PromptTemplate( input_variables=["texto_limpio","estilo"], template=plantilla_parafrasea
)# Ahora solo falta crear la cadena que cambia estilo utilizando como LLM a GPT3.5, esta cadena terminará creando una variable# a la salida llamada `texto_final`cadena_que_cambia_estilo = LLMChain( llm=llm_gpt3_5, prompt=prompt_parafraseo, output_key='texto_final')
Ahora siguiendo la misma estructura lógica, vamos a crear una nueva Chain que se encargue de parafrasear un texto de entrada:
# Texto_final es la variable de entrada, puesto que así la definimos en la cadena de parafraseoplantilla_resumen ="""Resume este texto:
{texto_final}
Resumen: """prompt_resumen = PromptTemplate( input_variables=["texto_final"], template=plantilla_resumen
)# Texto resumido será la variable final con la que termina nuestra secuencia de cadenascadena_que_resume = LLMChain( llm=llm_gpt3_5, prompt=prompt_resumen, output_key="texto_resumido")
Finalmente, para concluir vamos a unir todas nuestras cadenas entre ellas utilizando SequentialChain:
Nota:
Esta estructura de pensamiento es MUY similar a como PyTorch Organiza las capas de un modelo de DL.
Probemos entonces nuestra SequentialChain:
texto_entrada ="""
¡Monterrey es una ciudad impresionante! 🏙️
Es conocida por su impresionante paisaje de montañas ⛰️ y su vibrante cultura norteña.
¡No olvides visitar el famoso Museo de Arte Contemporáneo (MARCO)!
🖼️ Si eres fanático del fútbol, no puedes perderte un partido de los Rayados o de los Tigres. ⚽
Aquí te dejo algunos enlaces para que puedas conocer más sobre esta maravillosa ciudad:
https://visitamonterrey.com, https://museomarco.org, https://rayados.com, https://www.tigres.com.mx.
¡Monterrey te espera con los brazos abiertos! 😃🇲🇽
Monterrey es la capital y ciudad más poblada del estado mexicano de Nuevo León, además de la cabecera del
municipio del mismo nombre. Se encuentra en las faldas de la Sierra Madre Oriental en la región noreste de
México. La ciudad cuenta según datos del XIV Censo de Población y Vivienda del Instituto Nacional de
Estadística y Geografía de México (INEGI) en 2020 con una población de 3 142 952 habitantes, por lo cual
de manera individual es la 9.ª ciudad más poblada de México, mientras que la zona metropolitana de Monterrey
cuenta con una población de 5 341 175 habitantes, la cual la convierte en la 2.ª área metropolitana más
poblada de México, solo detrás de la Ciudad de México.8
La ciudad fue fundada el 20 de septiembre de 1596 por Diego de Montemayor y nombrada así en honor al castillo
de Monterrey en España. Considerada hoy en día una ciudad global, es el segundo centro de negocios y finanzas
del país, así como una de sus ciudades más desarrolladas, cosmopolitas y competitivas. Sirve como el
epicentro industrial, comercial y económico para el Norte de México.9 Según un estudio de Mercer Human
Resource Consulting, en 2019, fue la ciudad con mejor calidad de vida en México y la 113.ª en el mundo.10
La ciudad de Monterrey alberga en su zona metropolitana la ciudad de San Pedro Garza García, la cual es el
área con más riqueza en México y América Latina.11
"""ans = cadena_secuencial({'texto': texto_entrada,'estilo':'ciudad de méxico'})print(ans)
Respuesta esperada:
{'texto':
'\n¡Monterrey es una ciudad impresionante! 🏙️\nEs conocida por su impresionante paisaje de montañas ⛰️ y su vibrante
cultura norteña.\n¡No olvides visitar el famoso Museo de Arte Contemporáneo (MARCO)!\n🖼️ Si eres fanático del fútbol, no
puedes perderte un partido de los Rayados o de los Tigres. ⚽\nAquí te dejo algunos enlaces para que puedas conocer más
sobre esta maravillosa ciudad:\nhttps://visitamonterrey.com, https://museomarco.org, https://rayados.com, https://www.tigres.com.mx.
¡Monterrey te espera con los brazos abiertos! 😃🇲🇽\n\nMonterrey es la capital y ciudad más poblada del estado mexicano de
Nuevo León, además de la cabecera del \nmunicipio del mismo nombre. Se encuentra en las faldas de la Sierra Madre Oriental en
la región noreste de \nMéxico. La ciudad cuenta según datos del XIV Censo de Población y Vivienda del Instituto Nacional de
\nEstadística y Geografía de México (INEGI) en 2020 con una población de 3 142 952 habitantes, por lo cual \nde manera
individual es la 9.ª ciudad más poblada de México, mientras que la zona metropolitana de Monterrey \ncuenta con una población
de 5 341 175 habitantes, la cual la convierte en la 2.ª área metropolitana más \npoblada de México, solo detrás de la Ciudad
de México.8\u200b\n\nLa ciudad fue fundada el 20 de septiembre de 1596 por Diego de Montemayor y nombrada así en honor al
castillo \nde Monterrey en España. Considerada hoy en día una ciudad global, es el segundo centro de negocios y finanzas
\ndel país, así como una de sus ciudades más desarrolladas, cosmopolitas y competitivas. Sirve como el \nepicentro industrial,
comercial y económico para el Norte de México.9\u200b Según un estudio de Mercer Human \nResource Consulting, en 2019, fue
la ciudad con mejor calidad de vida en México y la 113.ª en el mundo.10\u200b \nLa ciudad de Monterrey alberga en su zona
metropolitana la ciudad de San Pedro Garza García, la cual es el \nárea con más riqueza en México y América Latina.11\u200b\n',
'estilo':
'ciudad de méxico',
'texto_resumido': '
Monterrey es una ciudad increíblemente hermosa y llena de vida, famosa por sus montañas y su cultura norteña. Es conocida
por su Museo de Arte Contemporáneo y por los equipos de fútbol Rayados y Tigres. Es la capital y la ciudad más grande del
estado de Nuevo León, con una población de más de 3 millones de habitantes. Es considerada una ciudad global y un importante
centro de negocios y finanzas en México. También es una de las ciudades más desarrolladas y con mejor calidad de vida en
el país. En resumen, Monterrey es una ciudad impresionante y llena de oportunidades.'}
Excelente, hemos podido aprender como unir varias cadenas entre ellas para crear un flujo de información efectivo a través
de SequentialChains
También dejo el input final.
entry ="""
¡Monterrey es una ciudad impresionante!🏙️
Es conocida por su impresionante paisaje de montañas⛰️ y su vibrante cultura norteña.¡No olvides visitar el famoso Museo de ArteContemporáneo(MARCO)!🖼️Si eres fanático del fútbol, no puedes perderte un partido de los Rayados o de los Tigres⚽Aquí te dejo algunos enlaces para que puedas conocer más sobre esta maravillosa ciudad:https://visitamonterrey.com,https://museomarco.org,https://rayados.com,https://www.tigres.com.mx.¡Monterrey te espera con los brazos abiertos! 😃🇲🇽
"""
No necesariamente. Aunque enviar system prompts y herramientas directamente a un modelo de OpenAI mejora la interactividad y la personalización en la generación de respuestas, no hace obsoletas las cadenas como las que se crean en LangChain. Estas cadenas permiten un procesamiento secuencial y la integración de múltiples transformaciones y modelos, facilitando tareas complejas. La combinación de ambas metodologías puede potenciar la funcionalidad de los chatbots, haciéndolos más versátiles y adaptables a diversas necesidades.
Le pregunté si con las cadenas de propts y las tool esta clase estaría obsoleta
