reasoning_engines.LangchainAgent
) per
sviluppare un'applicazione. In questa sezione esamineremo i passaggi per
personalizzare il tuo modello di applicazione. Ciò può essere utile se hai esigenze che vanno
oltre a quanto fornito dal modello predefinito.
Un modello di applicazione in Reasoning Engine è definito come classe Python. Per fare un esempio, il seguente codice Python è un esempio di applicazione LangChain di cui è possibile eseguire il deployment su Vertex AI (puoi assegnare alla variabile CLASS_NAME
un valore come MyAgent
):
from typing import Callable, Sequence
class CLASS_NAME:
def __init__(
self,
model: str,
tools: Sequence[Callable],
project: str,
location: str,
):
self.model_name = model
self.tools = tools
self.project = project
self.location = location
def set_up(self):
"""All unpickle-able logic should go here.
The .set_up() method should not be called for an object that is being
prepared for deployment.
"""
import vertexai
from langchain_google_vertexai import ChatVertexAI
from langchain.agents import AgentExecutor
from langchain.agents.format_scratchpad.tools import format_to_tool_messages
from langchain.agents.output_parsers.tools import ToolsAgentOutputParser
from langchain.tools.base import StructuredTool
from langchain_core import prompts
vertexai.init(project=self.project, location=self.location)
prompt = {
"input": lambda x: x["input"],
"agent_scratchpad": (
lambda x: format_to_tool_messages(x["intermediate_steps"])
),
} | prompts.ChatPromptTemplate.from_messages([
("user", "{input}"),
prompts.MessagesPlaceholder(variable_name="agent_scratchpad"),
])
llm = ChatVertexAI(model_name=self.model_name)
if self.tools:
llm = llm.bind_tools(tools=self.tools)
self.agent_executor = AgentExecutor(
agent=prompt | llm | ToolsAgentOutputParser(),
tools=[StructuredTool.from_function(tool) for tool in self.tools],
)
def query(self, input: str):
"""Query the application.
Args:
input: The user prompt.
Returns:
The output of querying the application with the given input.
"""
return self.agent_executor.invoke(input={"input": input})
Quando scrivi la classe Python, i tre metodi seguenti sono importanti per il motore di ragionamento:
__init__()
:- Utilizza questo metodo solo per i parametri di configurazione dell'applicazione. Ad esempio, puoi utilizzare questo metodo per raccogliere i parametri del modello e gli attributi di sicurezza come argomenti di input degli utenti. Puoi utilizzare questo metodo anche per raccogliere parametri come l'ID progetto, la regione, le credenziali dell'applicazione e le chiavi API.
- Il costruttore restituisce un oggetto che deve essere "riconoscibile" affinché sia possibile eseguire il deployment nel motore di ragionamento. Di conseguenza, devi inizializzare i client di servizio e stabilire le connessioni ai database nel metodo
.set_up
anziché nel metodo__init__
. - Questo metodo è facoltativo. Se non è specificato, Vertex AI usa il costruttore Python predefinito per la classe.
set_up()
:- Devi utilizzare questo metodo per definire la logica di inizializzazione dell'applicazione. Ad esempio, utilizzi questo metodo per stabilire connessioni ai database o ai servizi dipendenti, importare pacchetti dipendenti o dati precalcolati da utilizzare per la gestione delle query.
- Questo metodo è facoltativo. Se non è specificato, Vertex AI presuppone che l'applicazione non debba chiamare un metodo
.set_up
prima di gestire le query degli utenti.
query()
:- Devi utilizzare questo metodo per definire la logica di runtime che gestisca le query degli utenti. Ad esempio, puoi utilizzare questo metodo per generare contenuti con i modelli di IA generativa o recuperare dati in tempo reale da API esterne.
- Questo metodo è obbligatorio. Se non è specificato, il servizio
ReasoningEngine
restituisce un errore quando cerchi di creare un'istanza remota dell'applicazione. - Devi fornire a questo metodo una docstring chiara che ne definisca la funzione,
documenti i relativi attributi e fornisca annotazioni di tipo per gli input.
Evita argomenti variabili nel metodo
query
.
Testa l'applicazione in locale
Crea l'istanza dell'applicazione nella memoria locale utilizzando il seguente codice:
agent = CLASS_NAME(
model=model, # Required.
tools=[get_exchange_rate], # Optional.
project=PROJECT_ID,
location=LOCATION,
)
agent.set_up()
Puoi testare l'applicazione inviando query di prova all'istanza locale:
response = agent.query(
input="What is the exchange rate from US dollars to Swedish currency?"
)
La risposta è un dizionario simile al seguente:
{"input": "What is the exchange rate from US dollars to Swedish currency?",
# ...
"output": "For 1 US dollar you will get 10.7345 Swedish Krona."}