Function calling og API-integration
Bliv fortrolig med at få LLM'er til at kalde eksterne funktioner eller API'er, så de kan interagere med virkelige systemer.
Function calling og API-integration er en gratis Promptteknik til AI-lektion på CoddyKit. Dette er lektion 1 af 3. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Promptteknik til AI, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Promptteknik til AI-kurset indeholder 3 lektioner i alt.
Kald eksterne værktøjer
LLM'er er effektive, men de lever primært i en tekstverden. Hvad gør du, hvis de har brug for oplysninger fra den virkelige verden eller skal udføre handlinger?
Funktionskald gør det muligt for LLM'er at interagere med eksterne værktøjer og API'er! Det bygger bro mellem sprog og handling, så AI kan:
- Hente aktuelle oplysninger (vejret, aktiekurser)
- Udføre handlinger (sende e-mails, bestille aftaler)
- Oprette forbindelse til databaser eller tilpassede værktøjer
Det åbner for nye muligheder for AI-systemer.
LLM'ens rolle: Foreslå funktionskald
Når du aktiverer funktionskald, giver du LLM'en beskrivelser af de tilgængelige værktøjer (funktioner).
I stedet for at svare direkte kan LLM'en beslutte, at et værktøj kan hjælpe. Derefter returnerer den et struktureret "forslag" til et funktionskald, inklusive funktionens navn og dens argumenter.
Vigtigt: LLM'en udfører ikke selv funktionen. Den fortæller blot din applikation, hvilken funktion der skal kaldes, og med hvilke inddata.
Definition af dine værktøjer
For at bruge funktionskald skal du definere dine værktøjer (funktioner), så LLM'en kan forstå dem. Det indebærer normalt, at du angiver:
- Et navn på funktionen (f.eks.
get_current_weather) - En beskrivelse af, hvad den gør (afgørende for at LLM'en vælger korrekt)
- De parametre, den accepterer, inklusive deres typer og beskrivelser (f.eks.
location: string)
Dette "skema" fortæller LLM'en alt, hvad den skal vide for at foreslå et gyldigt funktionskald.
Definition af vejr-værktøj
Her er en konceptuel Python-definition af et vejr-værktøj. Bemærk den tydelige beskrivelse og parametrene. Det er det, du ville stille til rådighed for LLM'en.
Denne funktion repræsenterer det eksterne værktøj, som en LLM konceptuelt ville "kalde".
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"}
Udformning af prompts til værktøjer
For at få LLM'en til at bruge dine værktøjer skal din prompt tydeligt angive brugerens hensigt. Derefter beslutter LLM'en, om et værktøj kan hjælpe.
Du fortæller ikke LLM'en direkte "kald get_weather". I stedet stiller du et spørgsmål, der antyder det:
- "Hvordan er vejret i London?"
- "Kan du bestille et møde til mig i morgen?"
Med værktøjsbeskrivelserne til rådighed kan LLM'en udlede, at der er behov for et funktionskald.
LLM'ens forslag til funktionskald
Når LLM'en beslutter sig for at bruge et værktøj, giver den dig ikke et direkte svar. I stedet returnerer den et struktureret objekt, typisk JSON, der angiver den funktion, der skal kaldes, og dens argumenter.
Din applikation behandler derefter dette resultat.
Her er, hvad en LLM kunne foreslå, hvis den blev spurgt: "Hvordan er vejret i London?":
{
"tool_calls": [
{
"id": "call_abc123",
"function": {
"name": "get_current_weather",
"arguments": "{\"location\": \"London, UK\", \"unit\": \"celsius\"}"
},
"type": "function"
}
]
}Din app kører værktøjet
Når din applikation modtager LLM'ens forslag til et funktionskald, overtager den:
- Den identificerer den ønskede funktion (f.eks.
get_current_weather). - Den udtrækker argumenterne (f.eks.
"London, UK"). - Den udfører den faktiske Python-funktion (eller foretager API-kaldet) i din applikationsmiljø.
Det er her, handlingen fra den virkelige verden foregår uden for LLM'en.
LLM behandler værktøjsresultatet
Når din applikation har udført funktionen, modtager den et resultat (f.eks. {"temperature": "15", ...}).
Dette resultat sendes derefter tilbage til LLM'en sammen med den oprindelige samtalehistorik og anmodningen om funktionskaldet.
LLM'en bruger derefter disse nye oplysninger til at generere et svar i naturligt sprog på brugerens oprindelige forespørgsel.
Interaktion fra start til slut
Lad os samle det hele. Dette eksempel viser forløbet, hvor en brugers spørgsmål får en LLM til at foreslå et funktionskald, din app udfører det, og LLM'en derefter giver et endeligt svar.
Dette er en forenklet fremstilling af interaktionssløjfen.
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()
Tjek af funktionskald
Forestil dig, at en LLM returnerer en anmodning om et funktionskald. Hvad er det næste umiddelbare trin, din applikation bør udføre?
Opsummering: Værktøjer i praksis
I denne lektion undersøgte vi, hvordan LLM'er kan interagere med den virkelige verden gennem funktionskald og API-integration.
Vi lærte, at:
- Du definerer værktøjer (funktioner) med beskrivelser og parametre.
- LLM'en foreslår, hvilket værktøj der skal kaldes, og med hvilke argumenter.
- Din applikation udfører det faktiske værktøj og sender resultatet tilbage.
- LLM'en bruger derefter resultatet til at formulere et endeligt, velinformeret svar.
Denne effektive teknik gør det muligt for LLM'er at gå videre end ren tekstgenerering, så de kan udføre handlinger og hente opdaterede oplysninger.
Lær Promptteknik til AI med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 53
- Lektioner
- 199
Ofte stillede spørgsmål
Er lektionen “Function calling og API-integration” gratis?
Ja — alle 3 lektioner i læringssporet Promptteknik til AI, inklusive “Function calling og API-integration”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Promptteknik til AI-kurset indeholder 3 lektioner i alt.
Hvad lærer jeg i “Function calling og API-integration”?
Bliv fortrolig med at få LLM'er til at kalde eksterne funktioner eller API'er, så de kan interagere med virkelige systemer. Du øver dig i Promptteknik til AI med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Promptteknik til AI?
Der kræves ingen tidligere erfaring. Promptteknik til AI på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 3.
Hvor lang tid tager lektionen “Function calling og API-integration”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Promptteknik til AI-lektion?
Ja. Alle Promptteknik til AI-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Function calling og API-integration
- Prompting-systemer med flere agenter
- Tilpassede værktøjer og plugins til LLM'er