Aprovechar la potencia de ChatGPT y Perplexity dentro de un flujo de trabajo LangGraph abre interesantes posibilidades para aplicaciones basadas en IA. Al estructurar las interacciones como un grafo dinámico, LangGraph permite la colaboración sin fisuras entre varios LLM, lo que permite a ChatGPT refinar las consultas mientras Perplexity obtiene información del mundo real. Este enfoque modular y escalable transforma la IA de un simple chatbot en un sofisticado motor de conocimiento, listo para ofrecer inteligencia precisa y respaldada por datos a escala.
Tabla de contenidos
LangGraph: Orquestando Interacciones LLM
LangGraph revoluciona la forma en que se construyen las aplicaciones basadas en LLM al sustituir los flujos de trabajo rígidos y lineales por una estructura dinámica basada en gráficos. Cada nodo del gráfico representa una tarea distinta o una interacción LLM, lo que permite una coordinación perfecta entre varios modelos. Con soporte para bifurcaciones condicionales, ejecución paralela y toma de decisiones adaptativa, LangGraph permite a los desarrolladores crear sistemas de IA inteligentes, escalables y con gran capacidad de respuesta, adaptados a aplicaciones complejas del mundo real.
Perplejidad: Recuperación de información mejorada con LLMs
Perplexity aporta un conjunto puntero de LLM diseñados específicamente para la recuperación de información y la respuesta a preguntas de gran precisión. Entrenados en conjuntos de datos amplios y diversos, estos modelos destacan por ofrecer respuestas precisas, bien documentadas y contextualmente relevantes. Al integrar Perplexity en una aplicación LangChain, los desarrolladores pueden potenciar sus sistemas de inteligencia artificial con acceso a datos en tiempo real, garantizando que los usuarios reciban la información más actualizada y completa disponible.
Un sencillo flujo de trabajo de información sobre materias primas
Este artículo se centra en un flujo de trabajo simplificado que combina ChatGPT y Perplexity para recuperar información relacionada con la consulta de un usuario sobre una materia prima. El flujo de trabajo utiliza primero ChatGPT para resumir la consulta del usuario y luego utiliza Perplexity para proporcionar información de mercado más detallada relacionada con la consulta.
Recorrido del código: Explicación paso a paso
Vamos a diseccionar el código Python que implementa este flujo de trabajo simplificado:
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain_community.chat_models import ChatPerplexity
from typing import Any, Dict, Optional
import logging
import sys
import json
# Define the State (TypedDict)
class State(TypedDict):
user_query: str
chatgpt_response: str
perplexity_results: str
error: Optional[str]
Definición de Estado: El State TypedDict define la estructura para almacenar información a medida que el flujo de trabajo progresa. Contiene la consulta del usuario, la respuesta ChatGPT, los resultados de Perplejidad y cualquier error potencial.
# Define the SimpleCommoditySearch class
class SimpleCommoditySearch:
def __init__(self, openai_api_key: str, pplx_api_key: str, log_file: str = 'commodity_search.log'):
self.openai_api_key = openai_api_key
self.pplx_api_key = pplx_api_key
self._setup_workflow()
def _setup_workflow(self):
workflow = StateGraph(State)
# Define the nodes of the graph
workflow.add_node("chatgpt_interaction", self._chatgpt_interaction)
workflow.add_node("perplexity_search", self._perplexity_search)
# Define the edges connecting the nodes
workflow.add_edge(START, "chatgpt_interaction")
workflow.add_edge("chatgpt_interaction", "perplexity_search")
workflow.add_edge("perplexity_search", END)
self.chain = workflow.compile()
SimpleCommoditySearch Clase: Esta clase encapsula todo el flujo de trabajo.
__init__: Inicializa la clase con las claves API y configura el registro. Crucialmente, llama a _setup_workflow para definir la estructura LangGraph.
_setup_workflow: Define el flujo de trabajo LangGraph como un grafo dirigido. Añade dos nodos: chatgpt_interaction y perplexity_search, y los conecta con aristas para definir el flujo de ejecución.
def _chatgpt_interaction(self, state: State) -> Dict[str, Any]:
try:
llm = ChatOpenAI(model="gpt-4o-mini", openai_api_key=self.openai_api_key) # Or gpt-4
prompt = ChatPromptTemplate.from_messages([
("system", "You are a helpful assistant. Summarize the user query."),
("human", "{user_query}")
])
formatted_prompt = prompt.format(user_query=state["user_query"])
response = llm.invoke(formatted_prompt)
self.logger.info("ChatGPT interaction successful.")
return {"chatgpt_response": response.content, "error": None}
except Exception as e:
self.logger.error(f"ChatGPT interaction error: {e}")
return {"chatgpt_response": "", "error": str(e)}
_chatgpt_interaction: Esta función interactúa con ChatGPT. Toma la consulta del usuario del state, utiliza un ChatPromptTemplate para construir una consulta e invoca el LLM ChatGPT. La respuesta se almacena en el campo chatgpt_response del estado.
def _perplexity_search(self, state: Dict[str, Any]) -> Dict[str, Any]:
try:
chat_model = ChatPerplexity(
temperature=0,
pplx_api_key=self.pplx_api_key,
model="llama-3.1-sonar-small-128k-online" # Or another appropriate model
)
user_query = state["user_query"] # Use the original user query
prompt = ChatPromptTemplate.from_messages([
("system", "You are a helpful assistant providing commodity market information."),
("human", f"What is the current market situation related to: {user_query}? Provide recent data and analysis.")
])
formatted_prompt = prompt.format() # No need to pass variables since user_query is used directly
response = chat_model.invoke(formatted_prompt)
self.logger.info("Perplexity search successful.")
return {"perplexity_results": response.content, "error": None}
except Exception as e:
self.logger.error(f"Perplexity search error: {e}")
return {"perplexity_results": "", "error": str(e)}
_perplexity_search: Esta función interactúa con Perplexity. También toma la consulta del usuario del state, construye un prompt, e invoca el LLM de Perplexity usando la clase ChatPerplexity. Los resultados se almacenan en el campo perplexity_results del estado.
async def process_query(self, query: str) -> Dict[str, Any]:
try:
state = self.chain.invoke({"user_query": query})
return state # Return the complete state
except Exception as e:
self.logger.error(f"Error processing query: {e}")
return {"user_query": query, "chatgpt_response": "", "perplexity_results": "", "error": str(e)}
process_query: Esta función asíncrona es el punto de entrada para procesar las consultas de los usuarios.7 Invoca la cadena LangGraph con la consulta del usuario y devuelve el diccionario de states completo, que contiene los resultados de las interacciones ChatGPT y Perplexity.
# Example usage:
async def main():
openai_api_key = "YOUR_OPENAI_API_KEY" # Replace with your actual key
pplx_api_key = "YOUR_PERPLEXITY_API_KEY" # Replace with your actual key
commodity_search = SimpleCommoditySearch(openai_api_key, pplx_api_key)
query = "Price of wheat in Chicago"
result = await commodity_search.process_query(query)
print(json.dumps(result, indent=4)) # Print the result nicely formatted
if __name__ == "__main__":
import asyncio
asyncio.run(main())
Ejemplo de uso: La función principal (main) demuestra cómo utilizar la clase SimpleCommoditySearch. Crea una instancia de la clase, proporciona una consulta de ejemplo e imprime los resultados utilizando el formato de salida json.dumps. Recuerda sustituir las claves de API por sus claves reales.
Ejecutar el código
Para ejecutar este código, necesitarás instalar las librerías necesarias: langchain, langchain-openai, langchain-community, y typing-extensions. También necesitarás obtener las claves API tanto para OpenAI como para Perplexity y establecerlas como variables de entorno o proporcionarlas directamente en el código (no recomendado para producción).
Al combinar la destreza conversacional de ChatGPT con la potente recuperación de información de Perplexity, LangGraph abre las puertas a un nuevo nivel de flujos de trabajo basados en IA. Este dúo dinámico transforma las consultas sin procesar de los usuarios en información precisa y respaldada por datos, todo ello dentro de un gráfico estructurado y con estado. Con la flexibilidad para escalar, adaptar e integrar más LLM, este enfoque allana el camino para aplicaciones de IA más inteligentes y con mayor capacidad de respuesta que no se limitan a responder preguntas, sino que aportan inteligencia.