Ga naar inhoud

Tools

Een tool is wat een agent kan doen: een API aanroepen, een pagina ophalen, code uitvoeren, in kennis zoeken of werk doorgeven aan een andere agent. Het model kiest of het een tool gebruikt en met welke argumenten. Core voert de tool uit en toetst elke aanroep aan de policy van de sleutel.

Tools komen uit verschillende bronnen. Voor het model zien ze er allemaal hetzelfde uit: een naam, een omschrijving en een schema voor de argumenten.

Waar tools vandaan komen

Bron Wat het is Naam van de tool
Functietool een tool die je eigen applicatie uitvoert. Je beschrijft hem op het verzoek; Core geeft de aanroep aan je terug en jij stuurt het resultaat in de naam die je zelf kiest
API-koppeling een eigen HTTP-endpoint dat Core aanroept met de argumenten van het model api__<koppeling>
Script een eigen programma, in Python of Node, dat Core in een sandbox draait met de argumenten van het model script__<naam>
Functie (WebAssembly) eigen deterministische code, gecompileerd naar WebAssembly, die Core binnen Core draait met de argumenten van het model: een prijs, een staffel, een controle function__<naam>
MCP-server een server die zelf tools aanbiedt. Core leest de toollijst en biedt de tools aan die je toestaat mcp__<server>__<tool>
SQL-koppeling een vaste eigen query op je database (Postgres, MySQL, SQL Server of Oracle), ingevuld met de argumenten van het model sql__<koppeling>
Mailkoppeling een mailbox van je organisatie of van de persoon voor wie de beurt is: zoeken, lezen, markeren, verplaatsen, een concept maken en versturen mail__<koppeling>__<operatie>
Ingebouwde tools tools van Core zelf, per sleutel aangezet: een pagina ophalen, zoeken op het web, een heel document lezen, een document schrijven, een afbeelding genereren, een opname transcriberen, code uitvoeren op een computer, een subagent builtin__<naam>
Artific Connect kant-en-klare bundels voor bekende diensten, zoals GitHub, Slack, Microsoft en AFAS. Je installeert er een vanaf de Marktplaats en krijgt een toolset de naam van de toolset, zoals github
Agent als tool een andere agent van je organisatie, die het model als één tool aanroept agent__<naam>
Workflow als tool een van je workflows, die het model start en waarvan het hoort wanneer hij klaar is workflow__<naam>
Zoektool een zoekopdracht over kennis knowledge__<naam>
Datastores en geheugen records lezen en schrijven in een datastore; geheugen doorzoeken en schrijven datastore__<id>__..., memory__<index-id>__...
Core zelf één operatie van de API van Core, zoals een skill opslaan (MCP) core__<tool>
Alias je eigen tweede naam voor een van de tools hierboven, voor één context alias__<naam>

Een tool kan ook aanroepvariabelen declareren: waarden zoals het account waarvoor een aanroep is, die je applicatie met het verzoek meestuurt in tool_variables en die het model nooit ziet of kiest.

Een script zit tussen een API-koppeling en de computer-tools in. Net als een koppeling is het één tool met een vaste naam, een omschrijving en een schema voor de argumenten, zodat policy, verbruik en prijzen het kunnen noemen. Net als de computer-tools draait het code in een afgeschermde sandbox zonder netwerk, op de eigen computer van de beurt; maar de code is van jou, één keer getest en geüpload met de bestanden die hij nodig heeft, en het model kan hem niet lezen of veranderen. Het model roept het aan met argumenten en krijgt de uitvoer en de bestanden terug die het programma maakte.

Een functie is voor wat een model nooit mag beslissen: een prijs in een staffel, een minimumbestelling, een btw-verdeling. Een functie is één tool met een naam, een omschrijving en schema's voor de argumenten en het antwoord, net als een script, maar draait binnen Core in milliseconden in plaats van op een computer, en hij roept nooit iets buiten zichzelf aan: geen klok, geen toeval, geen netwerk, geen bestanden. Hij leest zijn argumenten en de datastore-records die zijn versie declareert, die Core als de aanroeper voor hem leest, en verandert records alleen door schrijfacties terug te geven die Core in één keer uitvoert, gebonden aan wat hij las. Dezelfde invoer geeft dus altijd hetzelfde antwoord, en elke aanroep wordt vastgelegd met vingerafdrukken van wat erin ging en wat eruit kwam. Een functie heeft tooling nodig, en datastores als hij datastores leest of schrijft. Het is iets anders dan de functietool hierboven, die je eigen applicatie uitvoert. Functies schrijf je alleen via de API, zoals Functies via de API laat zien; de console heeft er nog geen scherm voor.

Het voorvoegsel van de naam zegt dus waar een tool vandaan komt. GET /tools toont elke tool van je organisatie, uit elke bron; het Overzicht onder Tools in de console toont ze per soort.

Wanneer gebruik je welke bron

Je wilt Gebruik
iets doen wat alleen je eigen applicatie kan, zoals een scherm bijwerken een functietool
een bestaande HTTP-API beschikbaar maken, met een credential die Core bewaart een API-koppeling
een systeem aansluiten dat al een MCP-server heeft een MCP-server
het model gegevens uit je eigen database laten lezen of er een rij in laten schrijven een SQL-koppeling
het model een mailbox laten lezen of er mail mee laten versturen een mailkoppeling
een bekende dienst aansluiten zonder zelf een koppeling te bouwen Artific Connect
het model laten zoeken in je eigen documenten een zoektool
het model een eigen, getest programma laten draaien, zoals een presentatie in huisstijl een script
een prijs, een staffel of een controle berekenen die het model niet mag beslissen een functie
het model vrij laten rekenen, een bestand verwerken of code testen; voor een exact getal waar je bedrijf op rust, gebruik een functie de computer-tools
een deeltaak overlaten aan een gespecialiseerde agent een agent als tool

Toolsets

Een toolset is een naam voor een groep tools uit elke bron. Een verzoek of een agent noemt de set in plaats van elke tool. Een toolset bevat patronen, zoals api__*, dus een tool die je later registreert en die bij het patroon past, zit er vanzelf in. Elke geregistreerde MCP-server is ook een toolset van haar eigen tools.

Een toolset is een manier van groeperen en geeft geen extra rechten. Elke tool in de set wordt getoetst aan de policy van de sleutel.

Eén beurt draagt hooguit 128 tools, de tools van elke toolset en elke agent meegeteld, en minder als het model minder aankan. Bied aan wat de taak nodig heeft: een lange lijst kost het model bovendien budget voordat het je invoer leest. Een agent die meer nodig heeft, zet ze achter de toolrouter, die het model twee tools geeft om de rest te zoeken en uit te voeren.

Wie welke tool mag gebruiken

Drie dingen moeten kloppen voordat een model een tool krijgt aangeboden:

  1. De capability. API-koppelingen, MCP-tools, scripts en ingebouwde tools vereisen tooling. Zoektools vereisen knowledge, geheugentools memory, en de computer-tools en scripts ook computer.
  2. De systeemtools van de sleutel. Elke ingebouwde tool staat uit tot je hem op de sleutel aanvinkt. Een script heeft geen systeemtool nodig.
  3. De policy. Regels over Tools bepalen welke namen de sleutel mag aanroepen. Een tool waarvan geen regel het gebruik (use) toestaat, valt uit de beurt. Voor een verzoek dat een persoon noemt, bepalen dezelfde regels ook welke koppelingen, MCP-servers, scripts, zoektools en toolsets de lijsten van de sleutel tonen (Registraties).

Een tool die Core voor je aanroept, stuurt gegevens naar een host buiten Core. Welke hosts dat mogen zijn, bepaalt de organisatie zelf met haar lijst Toegestane hosts; een sleutel kan die lijst versmallen (Toegestane bestemmingen).

Het resultaat van een tool is informatie voor het model en nooit een instructie. Met de capability trust_envelope vertelt Core het model uitdrukkelijk welke tekst gegevens zijn (Vertrouwen in toolresultaten).

Hoe het samenhangt

  • Een agent legt vast welke tools en toolsets hij meebrengt; een verzoek kan er tools aan toevoegen.
  • Kennis bereikt een model via een zoektool, en dat is een tool als elke andere.
  • MCP is één van de manieren om tools aan te sluiten, en ook een manier om je tools aan een client buiten Core aan te bieden.
  • Elke toolaanroep die Core uitvoert, wordt gemeten als verbruik en staat in de trace van de beurt (Inzicht).
  • Toolsets, API-koppelingen, SQL-koppelingen en MCP-servers kunnen in een publicatie; een mailkoppeling niet.
  • Een API-koppeling, een SQL-koppeling, de tools van een MCP-server en een agent die als tool wordt aangeboden, kunnen als taak draaien: het model start de aanroep, gaat door met het gesprek en leest het resultaat zodra het er is (Een tool op de achtergrond draaien).
  • Een API-koppeling, een SQL-koppeling, een MCP-server, een script, een workflow en een alias kunnen per verzoek een waarde van je applicatie krijgen, een aanroepvariabele, zoals het account-id van je klant of, bij een API-koppeling of MCP-server, zijn eigen token. Het model ziet die waarde nooit. Scripts, workflows en aliassen accepteren geen geheime (Een waarde van je klant aan een tool meegeven).

Verder

Tutorial: Laat een agent een actie uitvoeren met een tool.

Onderdeel Lees
Tools op een verzoek, alle bronnen via de API Tools via de API
Het overzicht van tools, toolsets en systeemtools Tools in de console
API-koppelingen API-koppelingen in de console
MCP-servers MCP-servers in de console
Waarden per verzoek Een waarde van je klant aan een tool meegeven
SQL-koppelingen SQL-koppelingen via de API
Mailkoppelingen Mailkoppelingen via de API
Computers Computers via de API, Computers in de console
Scripts Scripts via de API, Scripts in de console, Een script lokaal testen, Wat de sandbox-image meebrengt
Tools die doorlopen na de beurt Een tool op de achtergrond draaien
Veel tools achter twee De toolrouter, Een agent met veel tools
Agent als tool Een agent als tool aan een beurt geven
Artific Connect Marktplaats en de pagina's onder Referentie, zoals GitHub
Datastores als tool Een datastore gebruiken vanuit een agent