Come creare un agente RAG LangChain con reportistica
Una delle parti più importanti del portare gli AI Agent in produzione con le tue applicazioni di retrieval augmented generation è monitorare ciò che fanno sotto la superficie. Sul mercato sono disponibili molti strumenti di monitoraggio, come Arize, TruEra e Portkey. In questo esempio, creiamo un AI Agent con LangChain, Milvus e OpenAI. Poi usiamo Portkey per monitorare il nostro utilizzo dei token, il conteggio dei token e la latenza delle richieste. Trova il codice per AI Agents Cookbooks in questo repo GitHub.
Introduzione allo stack tecnologico
Prima di entrare nel codice, esaminiamo brevemente i componenti di questo stack tecnologico. In questo tutorial, usiamo quattro componenti tecnologici principali: LangChain per orchestrare la tua app di retrieval augmented generation, Milvus come nostro database vettoriale per archiviare e inviare informazioni rilevanti a uno dei tuoi Large Language Models (LLM) preferiti, Portkey per i sistemi di monitoraggio e OpenAI per il nostro LLM.
LangChain
LangChain è il framework open-source di orchestrazione LLM più popolare a maggio 2024. È uno dei molti framework sul mercato per la retrieval augmented generation. La specialità di LangChain è il chaining. È particolarmente adatto ad assemblare input(o dati rilevanti) e output di large language models (LLM) e altre funzioni correlate. Puoi leggere di più sulla differenza tra i tre framework popolari in questo articolo su LangChain vs. LlamaIndex vs. Haystack.
Milvus
Milvus è il più popolare database vettoriale open-source e l’unico distribuito, spesso usato per archiviare le tue molteplici fonti di dati quando si creano applicazioni di retrieval augmented generation. Milvus esegue la ricerca di similarità vettoriale particolarmente bene in termini di scalabilità, flessibilità e funzionalità pronte per l’azienda rispetto ad altri database vettoriali. Per questo tutorial, eseguiremo Milvus tramite Docker Compose.
Portkey
Portkey presentava il più popolare LLM Gateway open-source a maggio 2024. È una delle molte soluzioni di monitoraggio per applicazioni LLM. Portkey fornisce monitoraggio instradando le chiamate attraverso il suo gateway. Monitora il costo, il conteggio dei token e la latenza delle tue chiamate. Portkey ti consente anche di configurare strumenti ausiliari come una cache semantica, simile a GPTCache.
OpenAI
OpenAI ha portato gli LLM all’attenzione del grande pubblico tramite ChatGPT. Da allora, ha rilasciato diverse versioni di GPT e ha incoraggiato molti concorrenti, come Mistral, Meta AI e altri, a entrare nel mercato.
Creazione dell’agente RAG LangChain
Ora che conosciamo le principali tecnologie con cui stiamo lavorando, costruiamo il nostro agente LangChain Retrieval Augmented Generation (RAG). Puoi eseguire le righe qui sotto in una cella di notebook Python, oppure puoi eseguirle direttamente nel terminale senza il ! all’inizio. Abbiamo bisogno di cinque librerie obbligatorie e di una sesta opzionale.
Le cinque librerie obbligatorie sono:
pymilvusper le azioni Milvuslangchainper LangChainlangchain-communityper le integrazioni della community, inclusa l’integrazione Milvus + LangChainlangchain-openaiper la libreria OpenAI + LangChainunstructuredper aiutare a caricare i dati
La sesta libreria opzionale è langchainhub. Usiamo questa libreria per accedere ai prompt degli agenti da LangChain hub, così non dobbiamo scriverli noi. Il secondo comando, `docker compose up—d', esegue il file Docker compose per avviare Milvus.
! pip install --upgrade --quiet pymilvus langchain langchain-community langchainhub langchain-openai unstructured
! docker-compose up -d
Configurazione
La prima parte della creazione del nostro Agente RAG è semplice. Tutto ciò che facciamo qui è caricare le nostre variabili d’ambiente ed effettuare una serie di importazioni. Le due variabili d’ambiente di cui avremo bisogno sono una chiave API Portkey e una chiave API OpenAI. Possiamo fare a meno della chiave Portkey se lo ospitiamo localmente.
from dotenv import load_dotenv
import os
load_dotenv()
OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
PORTKEY_API_KEY = os.environ["PORTKEY_API_KEY"]
Dividerò le importazioni in due sezioni: relative a LangChain e relative a Portkey. Abbiamo bisogno di nove importazioni da LangChain. Ci servono:
- DirectoryLoader per caricare dati da una directory specificata
- RecursiveCharacterTextSplitter per dividere il testo nei nostri documenti
- Milvus, per connetterci a Milvus
- OpenAIEmbeddings per creare vettori di embedding
hubè l’hub di LangChain da cui recuperiamo i promptcreate_retriever_toolper creare uno strumento in grado di recuperare dati- ChatOpenAI per usare GPT come endpoint di chat
- AgentExecutor per eseguire un agente
E
create_openai_tools_agentper creare un agente dagli strumenti e dall’endpoint OpenAI
Abbiamo bisogno di tre importazioni per gestire Portkey: l’URL del Portkey Gateway, una funzione per creare header e la libreria UUID per tracciare ogni esecuzione.
from langchain_community.document_loaders import DirectoryLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Milvus
from langchain_openai import OpenAIEmbeddings
from langchain import hub
from langchain.tools.retriever import create_retriever_tool
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from portkey_ai import PORTKEY_GATEWAY_URL, createHeaders
import uuid
Inserire documenti in Milvus
Il primo passo nella creazione di un agente RAG è inviare le tue fonti di dati, in questo caso i documenti, a Milvus. Per prima cosa, definiamo il nostro text splitter. Per questo esempio, definiamo una dimensione del chunk e una sovrapposizione del chunk. Questi due concetti sono ciò che utilizziamo per dividere un documento enorme in chunk di dimensioni ragionevoli. La sovrapposizione aiuta a tenere conto del recupero di informazioni contestuali e della continuità.
Una volta pronto un text splitter, carichiamo la directory e la dividiamo in documenti LangChain usando il text splitter. Poi definiamo la nostra funzione di embedding, in questo caso usando il modello linguistico OpenAIEmbeddings. Ora, con il documento e la funzione di embedding pronti, ci connettiamo a Milvus e carichiamo i chunk con la funzione embedding OpenAI.
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1024, chunk_overlap=128)
loader = DirectoryLoader("../city_data")
docs = loader.load_and_split(text_splitter=text_splitter)
embeddings = OpenAIEmbeddings()
db = Milvus.from_documents(
docs,
embeddings,
connection_args={"host": "127.0.0.1", "port": "19530"})
Creare uno strumento Retriever per RAG
Il primo passo nella creazione di RAG è inserire i tuoi documenti in un database vettoriale come Milvus. Quando si utilizza un framework come LangChain, il passo successivo è il componente di recupero delle informazioni, che consiste nel trasformare le fonti di dati del database vettoriale in un “retriever.” Questo oggetto prende automaticamente una stringa, la vettorizza e cerca nel database vettoriale risposte pertinenti.
Poiché stiamo creando un Agente AI, dobbiamo trasformare il nostro retriever in uno strumento. La creazione di uno strumento retriever in LangChain richiede tre parametri: il modello retriever stesso, il nome dello strumento e una descrizione della sua funzione.
Ora creiamo un elenco di strumenti e aggiungiamo questo strumento retriever. Questo passaggio diventa importante più avanti.
retriever = db.as_retriever()
tool = create_retriever_tool(
retriever,
"search_cities",
"Searches and returns excerpts from Wikipedia entries of many cities.",
)
tools = [tool]
Configurare l’Agente RAG
Iniziamo a configurare l’agente RAG ottenendo il prompt. Possiamo creare un prompt o recuperarlo direttamente dal LangChain hub, dove Harrison Chase ha un prompt pronto per un agente basato su OpenAI. L’ultima cosa che dobbiamo creare prima di ottenere l’LLM sono i nostri header Portkey.
Usiamo Portkey qui per monitorare il nostro utilizzo e controllare i dettagli interni delle nostre chiamate LLM, come la latenza, il numero di token utilizzati e il costo. Per i nostri header Portkey, abbiamo bisogno di quattro cose: la Portkey API Key, un UUID, il nome del provider LLM (OpenAI) e una configurazione Portkey. Il file di configurazione può essere una configurazione qualsiasi; puoi creare una configurazione predefinita per la dashboard utente.
Successivamente, istanziamo il nostro LLM tramite ChatOpenAI. Abbiamo bisogno di quattro parametri: la chiave API OpenAI, l’URL del gateway Portkey, gli header Portkey e la temperatura dell’LLM. Con tutto questo pronto, possiamo creare l’agente usando create_openai_tools_agent. Abbiamo bisogno solo di tre parametri per creare l’agente: l’LLM, l’elenco degli strumenti e il prompt.
prompt = hub.pull("hwchase17/openai-tools-agent")
portkey_headers = createHeaders(
api_key=PORTKEY_API_KEY,
trace_id=uuid.uuid4(),
provider="openai",
config="pc-basic-b390c9"
)
llm = ChatOpenAI(api_key=OPENAI_API_KEY, base_url=PORTKEY_GATEWAY_URL, default_headers=portkey_headers, temperature=0)
agent = create_openai_tools_agent(llm, tools, prompt)
Provare l’agente RAG
L’ultimo passaggio è creare una funzione per eseguire i task per il nostro agente, e poi il nostro agente è finalmente pronto per il campo. È un nome strano, se ci pensi. Comunque, la funzione che può eseguire il nostro workflow agentico accetta due parametri: l’agente strumento e gli strumenti stessi.
agent_executor = AgentExecutor(agent=agent, tools=tools)
Con il nostro agente pronto per l’esecuzione, possiamo invocarlo con un input. Per questo esempio, gli chiediamo di ottenere la dimensione di San Francisco.
result = agent_executor.invoke(
{
"input": "What is the size of San Francisco?"
}
)
L’agente può recuperare informazioni dai documenti creati sulla pagina Wikipedia di San Francisco. Ci dice che la dimensione di San Francisco è di 46,9 miglia quadrate o 121 chilometri quadrati.
Per controllare il nostro monitoraggio e vedere come sta andando il nostro LangChain RAG Agent, possiamo semplicemente controllare la dashboard di Portkey. Possiamo vedere che questa specifica domanda dell’agente RAG ci è costata 0,1191 centesimi, ha richiesto 787 ms e ha utilizzato 769 token.
Riepilogo della creazione di un LangChain RAG Agent
Questo tutorial ci ha insegnato come creare un AI Agent che esegue RAG usando LangChain. Oltre all’AI Agent, possiamo monitorare il costo, la latenza e l’utilizzo dei token del nostro agente usando un gateway. Il gateway che abbiamo scelto per questo specifico tutorial è Portkey.
Ci sono stati cinque passaggi nella creazione, nell’utilizzo e nel monitoraggio di questo LangChain RAG Agent. Per prima cosa, abbiamo dovuto affrontare il passaggio più noioso: la configurazione. Dopo aver completato la configurazione di base, abbiamo importato la nostra conoscenza esterna (documenti) in Milvus per eseguire la ricerca semantica per un recupero efficiente. Poi, abbiamo trasformato il nostro oggetto LangChain Milvus in un retriever e quel retriever in uno strumento retriever.
Se ci fossimo fermati alla fase di recupero, avremmo avuto la base per un RAG standard. Creare lo strumento ci permette di costruire un agente sopra di esso. Una volta che lo strumento era pronto, abbiamo definito un LLM instradato attraverso un gateway (Portkey) e gli abbiamo dato accesso agli strumenti. Successivamente, abbiamo posto una domanda al nostro RAG Agent e ottenuto una risposta. Quella esecuzione ci ha fornito informazioni su come l’agente ha eseguito l’LLM e sui dettagli delle risposte, il costo, la latenza e l’utilizzo dei token.
Altre risorse Langchain
Continua a leggere
Introducing Zilliz CLI and Agent Skills for Zilliz Cloud
Manage your vector database from your terminal or AI coding agent. Zilliz CLI and Agent Skills work with Claude Code, Cursor, Codex, and Copilot.
Announcing the General Availability of Single Sign-On (SSO) on Zilliz Cloud
SSO is GA on Zilliz Cloud, delivering the enterprise-grade identity management capabilities your teams need to deploy vectorDB with confidence.
Vector Databases vs. Hierarchical Databases
Use a vector database for AI-powered similarity search; use a hierarchical database for organizing data in parent-child relationships with efficient top-down access patterns.