Guide till att förstå, bygga och optimera API-anropande agenter Att-göra-lista API version: 1.0.0 vägar: /uppdrag: post: sammanfattning: Lägg till ett nytt uppdrag brödtext: krävs: sant innehåll: application/json: schema: typ: objekt egenskaper: beskrivning: typ: sträng svar: ‘201’: beskrivning: Uppdrag skapat get: sammanfattning: Hämta alla uppdrag svar: ‘200’: beskrivning: Lista över uppdrag Steg 2: Standardisera verktygsåtkomst Konvertera OpenAPI-specifikationen till Modellkontextprotokoll (MCP)-konfigurationer. Med hjälp av ett verktyg som Stainless.ai kan detta resultera i: Verktygsnamn Beskrivning Inmatningsparametrar Utdata beskrivning Lägg till uppdrag Lägger till ett nytt uppdrag i att-göra-listan. `beskrivning` (sträng, krävs): Uppdragets beskrivning. Uppdrags skapande bekräftelse. Hämta uppdrag Hämtar alla uppdrag från att-göra-listan. Ingen En lista över uppdrag med deras beskrivningar. Steg 3: Implementera agenten Med hjälp av Pydantic för datamodellering, skapa funktioner som motsvarar MCP-verktygen. Använd sedan en LLM för att tolka naturliga språkfrågor och välja det lämpliga verktyget och parametrarna. Steg 4: Kurera en kvalitetsutvärderingsdatamängd Skapa en datamängd: Fråga Önskat API-anrop Önskat resultat “Lägg till ‘Köp varor’ i min lista.” `Lägg till uppdrag` med `beskrivning` = “Köp varor” Uppdrags skapande bekräftelse “Vad är på min lista?” `Hämta uppdrag` Lista över uppdrag, inklusive “Köp varor” Steg 5: Optimera agentprompter och logik Använd DSPy för att förbättra prompterna, med fokus på tydliga instruktioner, verktygsval och parameterekstraktion med hjälp av den kuraterade datamängden för utvärdering och förbättring. Genom att integrera dessa byggstenar – från strukturerade API-definitioner och standardiserade verktygsprotokoll till rigorösa datapraxis och systematisk optimering – kan ingenjörsteam bygga mer kapabla, tillförlitliga och underhållbara API-anropande AI-agenter.

Artificiell intelligens (AI) spelar en alltmer viktig roll i teknologiföretag; AI-användningsfall har utvecklats från passiv informationsbehandling till proaktiva agenter som kan utföra uppgifter. Enligt en undersökning om global AI-antagande som genomfördes av Georgian och NewtonX i mars 2025, använder eller planerar 91% av de tekniska cheferna i tillväxtföretag och företag att använda agenter med AI.

API-anropande agenter är ett primärt exempel på denna förändring till agenter. API-anropande agenter använder stora språkmodeller (LLM) för att interagera med programvarusystem via deras programgränssnitt (API:er).

Till exempel kan agenter, genom att översätta naturliga språkkommandon till precisa API-anrop, hämta realtidsdata, automatisera rutinuppgifter eller till och med styra andra programvarusystem. Denna funktion förvandlar AI-agenter till användbara mellanhänder mellan mänsklig avsikt och programvarufunktion.

Företag använder för närvarande API-anropande agenter inom olika områden, inklusive:

• Konsumentapplikationer: Assistenter som Apples Siri eller Amazons Alexa har utformats för att förenkla vardagliga uppgifter, såsom att styra smarta hemenheter och göra reservationer.
• Företagsflöden: Företag har distribuerat API-agenter för att automatisera upprepande uppgifter som att hämta data från CRM-system, generera rapporter eller konsolidera information från interna system.
• Datahämtning och analys: Företag använder API-agenter för att förenkla åtkomsten till proprietära datamängder, prenumerationsbaserade resurser och offentliga API:er för att generera insikter.

I den här artikeln kommer jag att använda ett ingenjörscentrerat tillvägagångssätt för att förstå, bygga och optimera API-anropande agenter. Materialet i den här artikeln baseras delvis på den praktiska forskningen och utvecklingen som genomförts av Georgian’s AI Lab. Den motiverande frågan för mycket av AI Lab’s forskning inom området API-anropande agenter har varit: “Om en organisation har ett API, vad är det mest effektiva sättet att bygga en agent som kan kommunicera med det API:t med hjälp av naturligt språk?”

Jag kommer att förklara hur API-anropande agenter fungerar och hur man kan framgångsrikt arkitektera och konstruera dessa agenter för prestanda. Slutligen kommer jag att tillhandahålla en systematisk arbetsflöde som ingenjörsteam kan använda för att implementera API-anropande agenter.

I. Nyckeldefinitioner:

• API eller Programgränssnitt: En uppsättning regler och protokoll som möjliggör kommunikation och informationsutbyte mellan olika programapplikationer.
• Agent: Ett AI-system som är utformat för att uppfatta sin omgivning, fatta beslut och vidta åtgärder för att uppnå specifika mål.
• API-anropande agent: En specialiserad AI-agent som översätter naturliga språkinstruktioner till precisa API-anrop.
• Kodgenererande agent: Ett AI-system som assisterar i programvaruutveckling genom att skriva, modifiera och felsöka kod. Även om det är relaterat, fokuserar jag här främst på agenter som anropar API:er, även om AI också kan hjälpa till att bygga dessa agenter.
• MCP (Modellkontextprotokoll): Ett protokoll, särskilt utvecklat av Anthropic, som definierar hur LLM:er kan ansluta till och använda externa verktyg och datakällor.

II. Kärnuppgift: Översättning av naturligt språk till API-åtgärder

Den grundläggande funktionen hos en API-anropande agent är att tolka en användares naturliga språkförfrågan och omvandla den till en eller flera precisa API-anrop. Detta process vanligtvis involverar:

1. Avsiktsigenkänning: Att förstå användarens mål, även om det uttrycks tvetydigt.
2. Verktygsval: Att identifiera lämpliga API-slutpunkter (eller “verktyg”) från en uppsättning tillgängliga alternativ som kan uppfylla avsikten.
3. Parameterekstraktion: Att identifiera och extrahera nödvändiga parametrar för det valda API-anropet (eller anropen) från användarens fråga.
4. Utförande och svarsgenerering: Att göra API-anropet (eller anropen), ta emot svaret (eller svaren) och sedan syntetisera denna information till ett sammanhängande svar eller utföra en efterföljande åtgärd.

Tänk på en förfrågan som “Hej Siri, vad är vädret som idag?” Agenten måste identifiera behovet av att anropa ett väder-API, bestämma användarens nuvarande plats (eller tillåta specifikation av en plats) och sedan formulera API-anropet för att hämta väderinformationen.

För förfrågan “Hej Siri, vad är vädret som idag?”, kan ett exempel på API-anrop se ut så här:

GET /v1/väder?plats=New%20York&enheter=metric

Initiala högnivåutmaningar är inneboende i denna översättningsprocess, inklusive tvetydigheten hos naturligt språk och behovet av att agenten behåller kontexten över multi-stegsinteraktioner.

Till exempel måste agenten ofta “komma ihåg” tidigare delar av en konversation eller tidigare API-anropsresultat för att informera nuvarande åtgärder. Kontextförlust är ett vanligt felområde om det inte hanteras explicit.

III. Arkitektur för lösningen: Nyckelkomponenter och protokoll

Att bygga effektiva API-anropande agenter kräver en strukturerad arkitektonisk approach.

1. Definiera “verktyg” för agenten

För att en LLM ska kunna använda ett API måste API:ets funktioner beskrivas för den på ett sätt som den kan förstå. Varje API-slutpunkt eller funktion representeras ofta som ett “verktyg”. En robust verktygsdefinition inkluderar:

• En tydlig, naturlig språkbeskrivning av verktygets syfte och funktion.
• En exakt specifikation av dess ingångsparametrar (namn, typ, om det är obligatoriskt eller valfritt och en beskrivning).
• En beskrivning av utdata eller data som verktyget returnerar.

2. Rollen för Modellkontextprotokoll (MCP)

MCP är en kritisk möjliggörare för mer standardiserad och robust verktygsanvändning av LLM:er. Det tillhandahåller en strukturerad format för att definiera hur modeller kan ansluta till externa verktyg och datakällor.

MCP-standardisering är fördelaktig eftersom den möjliggör enklare integration av olika verktyg, främjar återanvändning av verktygsdefinitioner över olika agenter eller modeller. Dessutom är det en bästa praxis för ingenjörsteam, som börjar med väldefinierade API-specifikationer, såsom en OpenAPI-specifikation. Verktyg som Stainless.ai är utformade för att hjälpa till att konvertera dessa OpenAPI-specifikationer till MCP-konfigurationer, vilket förenklar processen att göra API:er “agentklara”.

3. Agentramverk och implementeringsval

Det finns flera ramverk som kan hjälpa till att bygga agenten själv. Dessa inkluderar:

• Pydantic: Även om det inte uteslutande är ett agentramverk, är Pydantic användbart för att definiera datastrukturer och säkerställa typsäkerhet för verktygsingångar och utgångar, vilket är viktigt för tillförlitlighet. Många anpassade agentimplementeringar använder Pydantic för denna strukturerade integritet.
• LastMiles mcp_agent: Detta ramverk är specifikt utformat för att fungera med MCP:er, och erbjuder en mer åsiktsbaserad struktur som överensstämmer med metoder för att bygga effektiva agenter, som beskrivs i forskning från platser som Anthropic.
• Intern ram: Det är också alltmer vanligt att använda AI-kodgenererande agenter (med verktyg som Cursor eller Cline) för att hjälpa till att skriva boilerplate-koden för agenten, dess verktyg och den omgivande logiken. Georgian’s AI Lab-erfarenhet av att arbeta med företag på agentera implementeringar visar att detta kan vara bra för att skapa mycket minimala, anpassade ramverk.

IV. Ingenjörskonst för tillförlitlighet och prestanda

Att säkerställa att en agent gör API-anrop tillförlitligt och presterar bra kräver fokuserad ingenjörsinsats. Två sätt att göra detta är (1) datamängds skapande och validering och (2) promptteknik och optimering.

1. Datamängdsskapande och validering

Träning (om tillämpligt), testning och optimering av en agent kräver en högkvalitativ datamängd. Denna datamängd bör bestå av representativa naturliga språkfrågor och deras motsvarande önskade API-anropssekvenser eller resultat.

• Manuell skapelse: Att manuellt kurera en datamängd säkerställer hög precision och relevans, men kan vara arbetskrävande.
• Syntetisk generering: Att generera data programmatiskt eller med hjälp av LLM:er kan skala datamängdsskapandet, men detta tillvägagångssätt presenterar betydande utmaningar. Georgian AI Lab’s forskning fann att säkerställa korrektheten och den realistiska komplexiteten hos syntetiskt genererade API-anrop och frågor är mycket svårt. Ofta var de genererade frågorna antingen för enkla eller omöjligt komplexa, vilket gjorde det svårt att mäta nyanserad agentprestanda. Omsorgsfull validering av syntetisk data är absolut kritisk.

För kritisk utvärdering kan en mindre, högkvalitativ, manuellt validerad datamängd ofta ge mer tillförlitliga insikter än en stor, bullrig syntetisk datamängd.

2. Promptteknik och optimering

Prestandan hos en LLM-baserad agent påverkas starkt av de prompter som används för att vägleda dess resonemang och verktygsval.

• Effektiv prompting innebär att tydligt definiera agentens uppgift, tillhandahålla beskrivningar av tillgängliga verktyg och strukturera prompten för att uppmuntra korrekt parameterekstraktion.
• Systematisk optimering med hjälp av ramverk som DSPy kan avsevärt förbättra prestandan. DSPy tillåter dig att definiera dina agentkomponenter (t.ex. moduler för tankegenerering, verktygsval, parameterformatering) och sedan använder en kompilatorliknande approach med få-skottsexempel från din datamängd för att hitta optimerade prompter eller konfigurationer för dessa komponenter.

V. En rekommenderad väg till effektiva API-agenter

Att utveckla robusta API-anropande AI-agenter är en iterativ ingenjörsdisciplin. Baserat på resultaten från Georgian AI Lab’s forskning, kan resultaten förbättras avsevärt med hjälp av en systematisk arbetsflöde som följer:

1. Börja med tydliga API-definitioner: Börja med välstrukturerade OpenAPI-specifikationer för de API:er som din agent kommer att interagera med.
2. Standardisera verktygsåtkomst: Konvertera dina OpenAPI-specifikationer till MCP. Verktyg som Stainless.ai kan underlätta detta och skapa en standardiserad väg för din agent att förstå och använda dina API:er.
3. Implementera agenten: Välj ett lämpligt ramverk eller tillvägagångssätt. Detta kan innebära att använda Pydantic för datamodellering inom en anpassad agentstruktur eller att använda ett ramverk som LastMiles mcp_agent som är byggt kring MCP.
   • Innan du gör detta, överväg att ansluta MCP till ett verktyg som Claude Desktop eller Cline och manuellt använda detta gränssnitt för att få en känsla för hur väl en generisk agent kan använda det, hur många iterationer det vanligtvis tar att använda MCP korrekt och alla andra detaljer som kan spara tid under implementeringen.
4. Kurera en kvalitetsutvärderingsdatamängd: Skapa manuellt eller validera noggrant en datamängd av frågor och förväntade API-interaktioner. Detta är avgörande för tillförlitlig testning och optimering.
5. Optimera agentprompter och logik: Använd ramverk som DSPy för att förbättra dina agentprompter och intern logik, med hjälp av din datamängd för att driva förbättringar i precision och tillförlitlighet.

VI. Ett illustrativt exempel på arbetsflödet

Här är ett förenklat exempel som illustrerar det rekommenderade arbetsflödet för att bygga en API-anropande agent:

Steg 1: Börja med tydliga API-definitioner

Tänk dig ett API för att hantera en enkel att-göra-lista, definierat i OpenAPI:

openapi: 3.0.0

info: