Function calling e integrazione delle API
Padroneggi la configurazione dei prompt affinché gli LLM chiamino funzioni o API esterne e interagiscano con sistemi del mondo reale.
Function calling e integrazione delle API è una lezione AI Prompt Engineering gratuita su CoddyKit. Questa è la lezione 1 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Prompt Engineering, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Prompt Engineering include 3 lezioni in totale.
Chiamare strumenti esterni
Gli LLM sono potenti, ma vivono principalmente in un mondo testuale. Cosa succede quando hanno bisogno di informazioni dal mondo reale o devono eseguire delle azioni?
Il function calling consente agli LLM di interagire con strumenti e API esterni. In questo modo colma il divario tra linguaggio e azione, permettendo all'IA di:
- Ottenere informazioni aggiornate (meteo, quotazioni azionarie)
- Eseguire azioni (inviare e-mail, prenotare appuntamenti)
- Connettersi a database o strumenti personalizzati
Questo apre nuove possibilità per i sistemi di IA.
Il ruolo dell'LLM: suggerire chiamate
Quando abilita il function calling, fornisce all'LLM le descrizioni degli strumenti (funzioni) disponibili.
Anziché rispondere direttamente, l'LLM potrebbe stabilire che uno strumento può essere utile. In tal caso restituisce una «proposta» strutturata per una chiamata di funzione, che include il nome della funzione e i relativi argomenti.
Importante: l'LLM non esegue direttamente la funzione. Indica semplicemente alla Sua applicazione quale funzione chiamare e con quali dati in ingresso.
Definire i propri strumenti
Per utilizzare il function calling, deve definire gli strumenti (funzioni) in un modo comprensibile per l'LLM. In genere è necessario fornire:
- Un nome per la funzione (ad esempio,
get_current_weather) - Una descrizione di ciò che fa (fondamentale affinché l'LLM effettui la scelta corretta)
- I parametri che accetta, inclusi i relativi tipi e descrizioni (ad esempio,
location: string)
Questo «schema» comunica all'LLM tutto ciò che deve sapere per proporre una chiamata valida.
Definizione dello strumento meteo
Ecco una definizione concettuale in Python di uno strumento meteo. Noti la descrizione e i parametri chiari. È questa l'interfaccia che esporrebbe all'LLM.
Questa funzione rappresenta lo strumento esterno che un LLM «chiamerebbe» a livello concettuale.
def get_current_weather(location: str, unit: str = "celsius"):
"""
Get the current weather in a given location.
Args:
location (str): The city and state, e.g. "London, UK"
unit (str): The unit of temperature, "celsius" or "fahrenheit"
Returns:
dict: Weather information.
"""
# In a real app, this would call a weather API
if location == "London, UK":
return {"temperature": "15", "unit": unit, "forecast": "cloudy"}
elif location == "New York, USA":
return {"temperature": "20", "unit": unit, "forecast": "sunny"}
else:
return {"temperature": "N/A", "unit": unit, "forecast": "unknown"}
Creare prompt per gli strumenti
Per incoraggiare l'LLM a utilizzare i Suoi strumenti, il prompt deve esprimere chiaramente l'intento dell'utente. Sarà poi l'LLM a stabilire se uno strumento può essere utile.
Non dica esplicitamente all'LLM «chiama get_weather». Ponga invece una domanda che lo lasci intendere:
- «Che tempo fa a Londra?»
- «Può prenotare una riunione per domani?»
Grazie alle descrizioni degli strumenti, l'LLM dedurrà la necessità di una chiamata di funzione.
Suggerimento di chiamata dell'LLM
Quando l'LLM decide di utilizzare uno strumento, non fornisce una risposta diretta. Restituisce invece un oggetto strutturato, in genere in formato JSON, che indica la funzione da chiamare e i relativi argomenti.
La Sua applicazione analizza quindi questo output.
Ecco cosa potrebbe proporre un LLM se gli venisse chiesto «Che tempo fa a Londra?»:
{
"tool_calls": [
{
"id": "call_abc123",
"function": {
"name": "get_current_weather",
"arguments": "{\"location\": \"London, UK\", \"unit\": \"celsius\"}"
},
"type": "function"
}
]
}La Sua applicazione esegue lo strumento
Quando riceve il suggerimento di chiamata di funzione dell'LLM, la Sua applicazione prende il controllo:
- Identifica la funzione richiesta (ad esempio,
get_current_weather). - Estrae gli argomenti (ad esempio,
"London, UK"). - Esegue l'effettiva funzione Python (o effettua la chiamata API) nell'ambiente della Sua applicazione.
È in questo punto che avviene l'azione nel «mondo reale», al di fuori dell'LLM.
L'LLM elabora l'output dello strumento
Dopo che la Sua applicazione ha eseguito la funzione, riceve un risultato (ad esempio, {"temperature": "15", ...}).
Questo risultato viene quindi restituito all'LLM insieme alla cronologia della conversazione originale e alla richiesta di chiamata della funzione.
L'LLM utilizza quindi queste nuove informazioni per generare una risposta in linguaggio naturale alla richiesta originale dell'utente.
Interazione dall'inizio alla fine
Riuniamo ora tutti gli elementi. Questo esempio mostra il flusso in cui una domanda dell'utente porta un LLM a proporre una chiamata di funzione, la Sua applicazione la esegue e l'LLM fornisce quindi una risposta finale.
Si tratta di una rappresentazione semplificata del ciclo di interazione.
def get_current_weather(location, unit="celsius"):
if location == "London, UK":
return {"temp": "15", "unit": unit, "forecast": "cloudy"}
return {"temp": "N/A", "unit": unit, "forecast": "unknown"}
def simulate_llm_response(user_query):
# LLM 'thinks' and decides to call a tool
if "weather in London" in user_query:
return {
"type": "tool_call",
"function": "get_current_weather",
"args": {"location": "London, UK"}
}
return {"type": "text", "content": "I cannot help with that."}
def simulate_llm_final_response(tool_output):
# LLM processes tool output and gives natural language
temp = tool_output.get("temp", "N/A")
forecast = tool_output.get("forecast", "unknown")
return f"The weather in London is {temp} degrees and {forecast}."
def main():
user_input = "What is the weather in London, UK?"
print(f"User: {user_input}")
llm_output = simulate_llm_response(user_input)
if llm_output["type"] == "tool_call":
func_name = llm_output["function"]
func_args = llm_output["args"]
print(f"LLM suggested calling: {func_name}({func_args})")
# Execute the function
tool_result = get_current_weather(**func_args)
print(f"Tool output: {tool_result}")
# Feed result back to LLM
final_answer = simulate_llm_final_response(tool_result)
print(f"LLM's final answer: {final_answer}")
else:
print(f"LLM: {llm_output['content']}")
if __name__ == "__main__":
main()
Verifica sul function calling
Immagini che un LLM restituisca una richiesta di chiamata di funzione. Qual è il passaggio immediatamente successivo che dovrebbe compiere la Sua applicazione?
Riepilogo: gli strumenti in azione
In questa lezione abbiamo esplorato come gli LLM possano interagire con il mondo reale attraverso il function calling e l'integrazione con le API.
Abbiamo imparato che:
- Si definiscono gli strumenti (funzioni) con descrizioni e parametri.
- L'LLM suggerisce quale strumento chiamare e con quali argomenti.
- La Sua applicazione esegue lo strumento effettivo e restituisce il risultato.
- L'LLM utilizza quindi il risultato per formulare una risposta finale informata.
Questa potente tecnica consente agli LLM di andare oltre la semplice generazione di testo, permettendo loro di eseguire azioni e recuperare informazioni aggiornate.
Domande Frequenti
La lezione «Function calling e integrazione delle API» è gratuita?
Sì — il testo completo di «Function calling e integrazione delle API» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Prompt Engineering, passa a CoddyKit PRO. Il corso AI Prompt Engineering include 3 lezioni in totale.
Cosa imparerò in «Function calling e integrazione delle API»?
Padroneggi la configurazione dei prompt affinché gli LLM chiamino funzioni o API esterne e interagiscano con sistemi del mondo reale. Eserciti AI Prompt Engineering con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare AI Prompt Engineering?
Non è richiesta alcuna esperienza precedente. AI Prompt Engineering su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 3.
Quanto tempo richiede la lezione «Function calling e integrazione delle API»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione AI Prompt Engineering?
Sì. Ogni lezione AI Prompt Engineering include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Function calling e integrazione delle API
- Sistemi di prompting multi-agent
- Strumenti e plugin personalizzati per gli LLM