Nota
- Questa esercitazione richiede l'accesso a Oracle Cloud. Per iscriversi a un account gratuito, consulta Inizia a utilizzare Oracle Cloud Infrastructure Free Tier.
- Utilizza valori di esempio per le credenziali, la tenancy e i compartimenti di Oracle Cloud Infrastructure. Quando completi il tuo laboratorio, sostituisci questi valori con quelli specifici del tuo ambiente cloud.
Crea un agente AI con il server del protocollo di comunicazione multi-agente per la risoluzione delle fatture
Introduzione
Le aziende che si occupano di un grande volume di prodotti - come distributori, industrie e catene di vendita al dettaglio - spesso affrontano la sfida di identificare i prodotti in base a descrizioni testuali imprecise, incomplete o varie. In ambienti in cui i dati vengono immessi manualmente, errori di battitura, abbreviazioni e nomi commerciali diversi possono rendere difficile identificare correttamente gli articoli in sistemi come Enterprise Resource Planning (ERP), Customer Relationship Management (CRM) e piattaforme di e-commerce.
In questo scenario, c'è una necessità comune di strumenti che possono:
-
Interpretare descrizioni informali o errate fornite dagli utenti.
-
Suggerisci i prodotti più simili basati sulla somiglianza semantica.
-
Garantire un fallback con algoritmi tradizionali (come la corrispondenza fuzzy) se la ricerca semantica non trova risultati pertinenti.
-
Esegui l'integrazione con le API e i flussi automatizzati di agenti intelligenti.
In questa esercitazione verrà descritto come creare un agente AI specializzato nella risoluzione delle incoerenze nelle fatture di reso dei clienti. L'agente è in grado di interagire con un server MCP che fornisce strumenti di ricerca vettoriale e recupero fatture, consentendo all'agente di trovare automaticamente la fattura AR originale della società in base alle informazioni fornite dal cliente.
Un server MCP (Model Context Protocol) è un componente software responsabile della mediazione della comunicazione tra agenti intelligenti e servizi esterni attraverso un protocollo standardizzato di messaggi e strumenti. Funge da ponte tra i modelli linguistici (LLM) e le API esistenti, consentendo agli agenti AI di accedere a funzionalità specifiche dei sistemi legacy senza la necessità di riscriverli o adattarli direttamente.
Come funziona
Server MCP:
- Mostra un set di strumenti denominati che rappresentano azioni o servizi che gli agenti possono chiamare.
- Ogni strumento può essere connesso a una funzione di database, a un'API REST, a un sistema legacy o a qualsiasi operazione programmabile.
- Riceve i comandi agente (in formato JSON), esegue il servizio corrispondente e restituisce una risposta standardizzata.
Utilizzo di applicazioni legacy
Le applicazioni legacy spesso forniscono già funzionalità tramite database, file o API interne. Con un server MCP è possibile:
- Incapsula le chiamate ai servizi REST, alle stored procedure o alle query SQL.
- Rendere questi servizi accessibili a un agente tramite un'interfaccia di comunicazione unificata.
- Integra i sistemi più vecchi con architetture moderne basate sull'AI conversazionale e sulla RAG.
Vantaggi
- Riutilizzo della business logic esistente.
- Non c'è bisogno di rifattorizzare i sistemi legacy.
- Consente agli agenti LLM di interagire con sistemi esterni in modo sicuro e controllato.
- Semplifica i test, il controllo delle versioni e la modularità nell'integrazione tra AI e servizi backend.
Questo agente si basa su un modello di linguaggio AI generativa di Oracle Cloud Infrastructure (OCI) e si integra con strumenti dichiarati dinamicamente gestiti da un server MCP.
Con l'integrazione di questi due componenti, il sistema abilita un agente basato su Oracle LLM:
- Utilizza strumenti in hosting remoto utilizzando MCP.
- Eseguire ricerche intelligenti per prodotti ed EAN.
- Individuare le fatture conto Avere corrispondenti.
- Registra tutto in osservabilità utilizzando Phoenix e OpenTelemetry.
Questo design modulare consente la riutilizzabilità e la facile evoluzione del sistema in domini diversi dalle fatture.
Obiettivi
-
Configurare un agente AI con LangGraph e LangChain per utilizzare prompt strutturati.
-
Integrare questo agente con un server MCP utilizzando il protocollo
stdio
. -
Utilizzare gli strumenti remoti registrati sul server per:
- Eseguire ricerche vettoriali dalle descrizioni dei prodotti.
- Identificare il codice EAN più probabile per un articolo.
- Cercare le fatture originali in base a criteri quali cliente, stato e prezzo.
-
Monitora l'esecuzione degli agenti in tempo reale utilizzando Phoenix e OpenTelemetry.
-
Simula una risoluzione reale dei problemi in base a un input JSON come:
{ "customer": "Customer 43", "description": "Harry Potter", "price": 139.55, "location": "RJ" }
Prerequisiti
-
Accesso a una tenancy OCI per gestire le risorse cloud. Puoi registrarti gratuitamente all'indirizzo
oracle.com/cloud/free
. -
Installare
version 3.12
o versioni successive di Python. -
Accesso a un account OCI con il servizio OCI Generative AI abilitato.
-
Installare e configurare la libreria Langchain Python.
-
Accedi al modello
cohere.command-r-08-2024
utilizzando OCI Generative AI. -
Installare le librerie ausiliarie:
oracledb
sentence_transformers
numpy
mcp-server-fastmcp
asyncio
langchain_core
langchain_community
mcp
langgraph
langchain_mcp_adapters
phoenix
(per l'osservabilità con OpenTelemetry)opentelemetry-sdk
,opentelemetry-exporter-otlp
-
Un server MCP funzionale con gli strumenti:
resolve_ean
search_vectorized_product
search_invoices_by_criteria
-
Configurare il file
server_invoice_items.py
da eseguire come server MCP che simula un ERP.
Installare requirements.txt con:
installazione pipeline -r requirements.txt
Task 1: Creare un Oracle Database 23ai (sempre gratuito)
In questo task verrà descritto come eseguire il provisioning di un Oracle Database 23ai in modalità Sempre gratuita. Questa versione offre un ambiente completamente gestito, ideale per lo sviluppo, il test e l'apprendimento, senza costi aggiuntivi.
-
Eseguire il login a OCI Console, andare a Oracle Database, Autonomous Database e fare clic su Crea istanza di Autonomous Database.
-
Immettere le informazioni riportate di seguito.
- Nome database: immettere un nome identificativo per l'istanza.
- Tipo di carico di lavoro: selezionare Data Warehouse o Elaborazione transazioni in base alle proprie esigenze.
- Compartimento: selezionare un compartimento appropriato per organizzare le risorse.
-
Selezionare Sempre gratis per assicurarsi che il provisioning dell'istanza venga eseguito gratuitamente.
-
Creare una password sicura per l'utente
ADMIN
, che verrà utilizzata per accedere al database. -
Rivedere le impostazioni e fare clic su Crea Autonomous Database. Attendere alcuni minuti prima che il provisioning dell'istanza venga eseguito e sia disponibile per l'uso.
Task 2: eseguire lo script di creazione della tabella Autonomous Database
Preparare il database per il nostro caso d'uso. Scaricare ed eseguire lo script SQL da qui: script.sql che crea tre tabelle essenziali (PRODUCTS
, INVOICE
e ITEM_INVOICE
) per lo scenario di riconciliazione delle fatture con gli agenti AI.
-
Andare a OCI Console, andare a Oracle Database, Autonomous Database e fare clic sul nome dell'istanza appena creata.
-
Fare clic su Azioni database e su SQL per aprire la console SQL nel browser.
-
Scaricare e aprire il file
script.sql
localmente e incollare tutti i contenuti nell'editor della console SQL. -
Fare clic su Esegui o premere Ctrl + Invio. Attendere la conferma che l'esecuzione dei comandi è riuscita.
-
Eseguire i comandi seguenti per verificare che le tabelle siano state create.
SELECT table_name FROM user_tables;
Task 3: Inserimento di dati di esempio nelle tabelle
Inserire dati fittizi che simuleranno uno scenario reale per l'applicazione degli agenti AI. Useremo due script SQL:
insert_products_books.sql
: inserisce un elenco di registri come prodotti, con le rispettive EAN e descrizioni.invoice_data_insert.sql
: inserisce i record di fatture conto Avere simulati, associati a clienti, prodotti e prezzi.
Questi dati verranno utilizzati dagli agenti AI per risolvere le incoerenze nelle fatture di reso.
-
Andare a OCI Console, andare a Oracle Database, Autonomous Database e fare clic sul nome dell'istanza appena creata.
-
Fare clic su Azioni database e su SQL per aprire la console SQL nel browser.
-
Scaricare e aprire il contenuto del file
insert_products_books.sql
e incollarlo nell'editor SQL. -
Fare clic su Esegui o premere Ctrl + Invio.
-
A questo punto, scaricare e aprire il contenuto del file
invoice_data_insert.sql
e incollarlo nell'editor. -
Fare clic su Esegui o premere Ctrl + Invio.
-
Eseguire il comando seguente per controllare i dati.
SELECT * FROM PRODUCTS; SELECT * FROM INVOICE; SELECT * FROM ITEM_INVOICE;
Task 4: Creazione e compilazione della funzione di ricerca avanzata nel database
Creare una funzione PL/SQL denominata fn_advanced_search
, che esegue ricerche intelligenti per le parole chiave nelle descrizioni dei prodotti. Questa funzione verrà utilizzata dagli agenti AI come parte dello strumento resolve_ean
, consentendo loro di trovare il codice EAN più vicino in base alla descrizione fornita da un cliente sulla nota di reso.
Cosa fa la funzione?
-
Tokenizzazione dei termini di input (ad esempio,
harry poter stone
diventa [harry
,poter
,stone
]) -
Tecniche di ricerca con punteggio:
-
Ricerca diretta nelle descrizioni
(LIKE '%term%')
→ +3 punti. -
Ricerca telefonica mediante
SOUNDEX
→ +2 punti. -
Ricerca ortografica simile mediante
UTL_MATCH.EDIT_DISTANCE <= 2
→ +1 punto.
-
-
Logica punteggio:
- Somma i punti per ogni prodotto.
- Restituisce solo i prodotti con punteggio totale > 0.
-
Formato restituzione:
I prodotti vengono restituiti come oggetti di tipo
result_product
contenenti:code
(EAN).description
(descrizione del prodotto).similarity
(punteggio di ricerca calcolato).
Seguire i passi indicati:
-
Copiare e incollare lo script
similarity_search.sql
completo nella console SQL di Autonomous Database.Tra queste sono incluse le seguenti:
- Creazione della tabella
products
(se non è già stata eseguita). - Creazione di un indice di testo.
- Tipi
product_result
eproduct_result_tab
. - Funzione
fn_advanced_search
. - Test opzionali.
- Creazione della tabella
-
Eseguire lo script completo. Il risultato deve essere
Function created
eType created
. -
Eseguire la seguente query per testare la funzione con descrizioni simulate.
SELECT * FROM TABLE(fn_advanced_search('harry poter askaban')) ORDER BY similarity DESC;
Task 5: Vectorizzare i prodotti per la ricerca semantica con l'intelligenza artificiale
In questo compito, completeremo la ricerca avanzata basata su SQL con un nuovo approccio basato su vettori semantici. Ciò sarà particolarmente utile per gli agenti AI che utilizzano incorporamenti (rappresentazioni numeriche di frasi) per confrontare la somiglianza tra le descrizioni dei prodotti - in modo più flessibile e intelligente rispetto alle ricerche di parole o fonetiche.
Per fare ciò, utilizzeremo lo script Python (process_vector_products.py
), che si connette al database Oracle, estrae i prodotti dalla tabella PRODUCTS
, trasforma le loro descrizioni in vettori (embeddings) e crea un indice vettoriale utilizzando il database Oracle stesso.
Cosa fa lo script?
- Legge i prodotti dalla tabella
products
utilizzandooracledb
. - Genera le integrazioni utilizzando il modello
all-MiniLM-L6-v2
dal pacchettosentence-transformers
. - Creare la tabella
embeddings_products
per memorizzare i vettori direttamente in Oracle. - Inserire o aggiornare i record e salvare il vettore come BLOB binario (in formato serializzato
float32
).
Nota: gli incorporamenti vengono convertiti in byte con
np.float32.tobytes()
da memorizzare come BLOB. Per recuperare i vettori, utilizzarenp.frombuffer(blob, dtype=np.float32)
.
Questo formato consente di eseguire ricerche future di somiglianza direttamente utilizzando SQL o caricando i vettori dal database per le operazioni con np.dot
, cosine_similarity
o l'integrazione con LLM.
Questo script genera integrazioni semantiche per i prodotti e scrive questi vettori nel database Oracle 23ai. I punti principali sono evidenziati di seguito:
-
Configura la connessione a Oracle mediante Wallet.
Il codice utilizza la libreria
oracledb
in modalità thin e configura l'accesso sicuro utilizzando un Oracle Wallet.os.environ["TNS_ADMIN"] = WALLET_PATH connection = oracledb.connect( user=USERNAME, password=PASSWORD, dsn=DB_ALIAS, ... )
-
Consulenza della tabella dei prodotti.
La tabella
products
contiene i dati originali (ID, codice e descrizione). Queste descrizioni sono utilizzate come base per la generazione dei vettori semantici.cursor.execute("SELECT id, code, description FROM products")
-
Genera integrazioni con
sentence-transformers
Il modello
all-MiniLM-L6-v2
viene utilizzato per trasformare le descrizioni dei prodotti in vettori numerici ad alta dimensione.model = SentenceTransformer('all-MiniLM-L6-v2') embeddings = model.encode(descriptions, convert_to_numpy=True)
-
Creare la tabella incorporamenti (se non esiste).
La tabella
embeddings_products
viene creata in modo dinamico con i seguenti campi:id
: identificativo del prodotto (chiave primaria).code
: Codice prodotto.description
: descrizione originale.vector
: BLOB contenente il vettore serializzato infloat32
.
CREATE TABLE embeddings_products ( id NUMBER PRIMARY KEY, code VARCHAR2(100), description VARCHAR2(4000), BLOB vector )
Nota: la creazione utilizza
EXECUTE IMMEDIATE
all'interno di un fileBEGIN...EXCEPTION
per evitare un errore se la tabella esiste già. -
Inserire o aggiornare utilizzando
MERGE
.Per ogni prodotto, il vettore viene convertito in byte (
float32
) e inserito o aggiornato nella tabellaembeddings_products
utilizzando unMERGE INTO
.vector_bytes = vector.astype(np.float32).tobytes()
MERGE INTO embeddings_products ...
Esecuzione dello script:
Tenere presente che è necessario scaricare e configurare Oracle Wallet. Eseguire nel terminale.
python process_vector_products.py
Fatto. I prodotti nel database sono stati vettorializzati.
Perché è importante?
La ricerca vettoriale è molto efficace per trovare prodotti anche quando la descrizione è soggettiva, imprecisa o in linguaggio naturale.
Comprendere il codice: agente LLM con server MCP
Questo progetto è composto da 3 componenti principali:
- ReAct Agente con LangGraph e LLM OCI (
main.py
). - Server MCP con strumenti di risoluzione delle fatture (
server_invoice_items.py
). - Cerca prodotti simili con OCI Generative AI e FAISS (
product_search.py
).
Comprendi le funzionalità di ogni componente e evidenzia in dettaglio le parti più importanti del codice.
-
Agente ReAct con LangGraph e LLM da OCI:
Questo componente esegue l'applicazione principale, in cui l'utente interagisce con l'agente in base al Large Language Model (LLM) di Oracle Cloud. Comunica con il server MCP utilizzando un protocollo
stdio
.Caratteristiche principali:
-
Configurazione della telemetria con Phoenix e OpenTelemetry.
px.launch_app() ... trace.set_tracer_provider(provider)
-
Creare un modello LLM utilizzando
ChatOCIGenAI
.llm = ChatOCIGenAI( model_id="cohere.command-r-08-2024", ... )
-
Definizione del prompt orientato ai task per la riconciliazione delle fatture.
prompt = ChatPromptTemplate.from_messages([ ("system", """You are an agent responsible for resolving inconsistencies in invoices...""), ("placeholder", "{messages}") ])
-
Esecuzione del server MCP locale mediante
stdio
.# Run the client with the MCP server async def main(): async with MultiServerMCPClient( { "InvoiceItemResolver": { "command": "python", "args": ["server_invoice_items.py"], "transport": "stdio", }, } ) as client:
-
Loop interazione utente principale.
while True: query = input("You: ") ... result = await agent_executor.ainvoke({"messages": memory_state.messages})
-
Integrazione con gli strumenti esposti dal server MCP.
agent_executor = create_react_agent( model=llm, tools=tools, prompt=prompt, )
-
Server MCP multipli.
Se si desidera utilizzare più server MCP, includere i server qui:
# Run the client with the MCP server async def main(): async with MultiServerMCPClient( { "InvoiceItemResolver": { "command": "python", "args": ["server_invoice_items.py"], "transport": "stdio", }, "InvoiceItemResolver": { "command": "python", "args": ["another_mcp_server.py"], "transport": "stdio", }, ... } ) as client: tools = client.get_tools() if not tools: print("❌ No MCP tools were loaded. Please check if the server is running.") return
Prompt:
Il prompt è essenziale per stabilire il processo e le regole operative per l'agente AI.
-
-
Server MCP con strumenti di risoluzione:
Questo server risponde alle chiamate degli agenti fornendo strumenti che accedono a Oracle Database con informazioni su prodotti e fatture.
Caratteristiche principali:
-
Inizializzazione del server MCP con il nome
InvoiceItemResolver
.mcp = FastMCP("InvoiceItemResolver")
-
Connessione a Oracle Database mediante Oracle Wallet.
connection = oracledb.connect( user=USERNAME, password=PASSWORD, dsn=DB_ALIAS, wallet_location=WALLET_PATH, ... )
-
Implementazione degli strumenti MCP.
-
search_vectorized_product
:Ricerche per prodotti simili con incorporamenti.
@mcp.tool() def search_vectorized_product(description: str) -> dict: """ Searches for a product by description using embeddings. """ return sercher.search_similar_products(description)
-
resolve_ean
:Risolve un EAN in base alla somiglianza della descrizione.
@mcp.tool() def resolve_ean(description: str) -> dict: result = execute_search_ean(description) ... return {"ean": result[0]["code"], ...}
-
search_invoices_by_criteria
:Cerca le fatture conto Avere in base a più filtri.
@mcp.tool() def search_invoices_by_criteria(customer: str = None, state: str = None, price: float = None, ean: str = None, margin: float = 0.05) -> list: """ Searches for outbound invoices based on customer, state, EAN, and approximate price. Allows one or more fields to be omitted. As long as an EAN has not been established, it is not useful to use this service. """ query = """ SELECT nf.no_invoice, nf.name_customer, nf.state, nf.date_print, inf.no_item, inf.code_ean, inf.description_product, inf.value_unitary FROM invoice nf JOIN item_invoice inf ON nf.no_invoice = inf.no_invoice WHERE 1=1 """ params = {} #if customer: query += " AND LOWER(nf.name_customer) LIKE LOWER(:customer)" params["customer"] = f"%{customer}%" #if state: query += " AND LOWER(nf.state) = LOWER(:state)" params["state"] = state #if ean: query += " AND inf.code_ean = :ean" params["ean"] = ean if price is not None: query += " AND inf.value_unitary BETWEEN :price_min AND :price_max" params["price_min"] = price * (1 - margin) params["price_max"] = price * (1 + margin) result = execute_query(query, params) return [ dict(zip( ["no_invoice", "name_customer", "state", "date_print", "no_item", "code_ean", "description_product", "value_unitary"], row )) for row in result ]
-
-
Eseguire il server in modalità
stdio
.if __name__ == "__main__": mcp.run(transport="stdio")
-
-
Cerca prodotti simili con OCI Generative AI e Vector Database:
Questo modulo
product_search.py
implementa una classe Python che consente di cercare prodotti semanticamente simili da una descrizione testuale, utilizzando:- Integrazione da OCI Generative AI.
- Indici vettoriali con Oracle Database 23ai.
- Confronti non accurati con RapidFuzz come fallback.
Task 6: Configurazione del modello e degli incorporamenti nell'agente MCP
Configura il modello di linguaggio e le integrazioni utilizzate dall'agente conversazionale in base al protocollo MCP, utilizzando i servizi OCI Generative AI.
-
Configurare il modello di lingua (LLM, Language Model).
Il modello linguistico è responsabile dell'interpretazione dei messaggi, della generazione di risposte e dell'azione come cervello principale dell'agente.
-
Eseguire la configurazione nel file
main.py
.from langchain_community.chat_models.oci_generative_ai import ChatOCIGenAI llm = ChatOCIGenAI( model_id="cohere.command-r-08-2024", service_endpoint="https://inference.generativeai.us-chicago-1.oci.oraclecloud.com", compartment_id="ocid1.compartment.oc1..aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", auth_profile="DEFAULT", model_kwargs={"temperature": 0.1, "top_p": 0.75, "max_tokens": 2000} )
Parametro Descrizione model_id
ID modello AI generativa, ad esempio cohere.command-r-08-2024
service_endpoint
Endpoint regionale del servizio AI generativa compartment_id
OCID del compartimento OCI auth_profile
Nome del profilo configurato nel file ~/.oci/config
model_kwargs
Temperatura, top-p e risposta -
Elenca i modelli disponibili.
-
Uso dell'interfaccia CLI OCI:
oci generative-ai model list --compartment-id <seu_compartment_id>
-
Utilizzando l'SDK Python:
from oci.generative_ai import GenerativeAiClient from oci.config import from_file config = from_file(profile_name="DEFAULT") client = GenerativeAiClient(config) models = client.list_models(compartment_id=config["compartment_id"]) for model in models.data: print(model.display_name, model.model_id)
-
-
-
Configura le integrazioni per la ricerca semantica.
La ricerca di prodotti simili o informazioni contestuali dipende dalle integrazioni vettoriali.
Esempio di utilizzo nell'agente:
@mcp.tool() def search_vectorized_product(description: str) -> dict: """ Searches for a product by description using embeddings. """ return sercher.search_similar_products(description)
Modificare i parametri (
product_search.py
) come indicato di seguito:class SimilarProductSearch: def __init__( self, top_k=5, minimum_distance=1.0, model_id="cohere.embed-english-light-v3.0", service_endpoint="https://inference.generativeai.us-chicago-1.oci.oraclecloud.com", compartment_id="ocid1.compartment.oc1..aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", auth_profile="DEFAULT", wallet_path="/WALLET_PATH/Wallet_oradb23ai", db_alias="oradb23ai_high", username="USER", password="Password" ):
Parametro Descrizione top_k
Numero di consigli restituiti. minimum_distance
Distanza massima per considerare il risultato rilevante. model_id
ID del modello di incorporamento in OCI (ad esempio, cohere.embed-english-light-v3.0
).service_endpoint
Endpoint regionale dell'AI generativa OCI. compartment_id
OCID compartimenti. auth_profile
Nome del profilo nel file ~/.oci/config
.wallet_path
Percorso del wallet di Oracle Database 23ai. db_alias
Alias del database. username
Utente database. password
Password del database. Configurare il server MCP:
Proprio come hai fatto quando esegui il codice
process_vector_products.py
, dovrai configurare Oracle Wallet per il database Oracle Database 23ai.Modificare i parametri in base alle impostazioni:
import os # Oracle Wallet settings WALLET_PATH = "/path/to/Wallet" DB_ALIAS = "oradb23ai_high" USERNAME = "admin" PASSWORD = "..." # Define the environment variable required for the Oracle client os.environ["TNS_ADMIN"] = WALLET_PATH
E poi eseguire
process_vector_products.py
per vettorializzare i prodotti in Oracle Database 23ai.python process_vector_products.py
Con questo, il modello LLM e le integrazioni sono pronti per essere utilizzati dall'agente MCP con LangGraph e LangChain.
Task 7: Test ricerca descrizione prodotto e fattura
-
Eseguire il file
main.py
utilizzando il comando seguente.python main.py
-
Quando viene visualizzato il prompt Voi:, immettere l'istruzione seguente.
{ "customer": "Customer 108", "description": "Harry Poter askaban", "price": 82.26, "location": "SP"}
Nota: il nome del libro Harry Potter e Azkaban è scritto in modo errato, ma il motore può trovarlo senza problemi.
Tenere presente che i servizi sono stati eseguiti:
fetch_vectorized_product resolve_ean search_invoices_by_criteria
-
Inserire ora l'istruzione seguente.
{ "customer": "Customer 108", "description": "Harry Poter askaban", "price": 82.26}
Non è stato trovato alcun record fattura. L'ubicazione è la chiave per trovare una fattura.
-
Inserire ora l'istruzione seguente.
{ "customer": "Customer 108", "description": "Harry Poter", "location": "SP"}
Questa volta, immettiamo l'ubicazione, ma omettiamo il prezzo unitario.
La fattura è stata trovata. Questo perché il prezzo non è fondamentale, ma aiuta a colmare il divario per essere più assertivo.
Di seguito sono riportati alcuni esempi di test.
{ "customer": "Customer 108", "description": "Harry Poter askaban", "price": 82.26, "location": "SP"} { "customer": "Customer 108", "description": "Harry Poter askaban", "price": 82.26} { "customer": "Customer 108", "description": "Harry Poter askaban", "location": "SP"} { "customer": "Customer 108", "description": "Harry Poter askaban", "price": 82.26, "location": "RJ"} { "customer": "Customer 125", "description": "Harry Potter Chamber", "price": 79.16, "location": "SP"} { "customer": "Customer 125", "description": "Harry Potter Chamber", "price": 79.15, "location": "SP"}
Task 8: Visualizza l'osservabilità con Phoenix
Immettere http://localhost:6006/
nel browser per visualizzare l'osservabilità con Phoenix.
Collegamenti correlati
Conferme
- Autore - Cristiano Hoshikawa (Solution Engineer A-Team di Oracle LAD)
Altre risorse di apprendimento
Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti di formazione gratuiti sul canale YouTube di Oracle Learning. Inoltre, visitare education.oracle.com/learning-explorer per diventare Oracle Learning Explorer.
Per la documentazione del prodotto, visitare Oracle Help Center.
Build an AI Agent with Multi-Agent Communication Protocol Server for Invoice Resolution
G35143-05
Copyright ©2025, Oracle and/or its affiliates.