Aller au contenu
Two brightly colored 8-bit puzzle pieces interlock; one displays a robot head to symbolize AI, the other shows a sun, cloud, and math symbol. Nearby are a simple gear and a browser window, all in a bold outlined, minimal geometric style. No people or background.

Outils

AI generated translation.

Vous pouvez enregistrer des outils (également appelés fonctions) que le LLM peut décider d’appeler dans le cadre de l’assemblage de la réponse. Voir fonctions OpenAI, outils Ollama, ou utilisation des outils Anthropic.

Tous les modèles LLM ne supportent pas les outils. Dans ces cas, GenAIScript prend également en charge un mécanisme de secours pour implémenter l’appel d’outils via des invites système (voir Fallback Tools).

Play

defTool est utilisé pour définir un outil qui peut être appelé par le LLM. Il prend un schéma JSON pour définir l’entrée et s’attend à une sortie sous forme de chaîne. Les paramètres sont définis en utilisant le schéma des paramètres.

Le LLM décide lui-même d’appeler cet outil !

defTool(
"current_weather",
"get the current weather",
{
city: "",
},
(args) => {
const { location } = args
if (location === "Brussels") return "sunny"
else return "variable"
}
)

Dans l’exemple ci-dessus, nous définissons un outil appelé current_weather qui prend un lieu en entrée et retourne la météo.

Cet exemple utilise l’outil current_weather pour obtenir la météo à Bruxelles.

weather.genai.mjs
script({
model: "small",
title: "Weather as function",
description:
"Query the weather for each city using a dummy weather function",
temperature: 0.5,
files: "src/cities.md",
tests: {
files: "src/cities.md",
keywords: "Brussels",
},
})
$`Query the weather for each listed city and return the results as a table.`
def("CITIES", env.files)
defTool(
"get_current_weather",
"get the current weather",
{
type: "object",
properties: {
location: {
type: "string",
description: "The city and state, e.g. San Francisco, CA",
},
},
required: ["location"],
},
(args) => {
const { context, location } = args
const { trace } = context
trace.log(`Getting weather for ${location}...`)
let content = "variable"
if (location === "Brussels") content = "sunny"
return content
}
)

Cet exemple utilise l’évaluateur d’expressions mathématiques pour évaluer une expression mathématique.

math-agent.genai.mjs
script({
title: "math-agent",
model: "small",
description: "A port of https://ts.llamaindex.ai/examples/agent",
parameters: {
question: {
type: "string",
default: "How much is 11 + 4? then divide by 3?",
},
},
tests: {
description: "Testing the default prompt",
keywords: "5",
},
});
defTool("sum", "Use this function to sum two numbers", { a: 1, b: 2 }, ({ a, b }) => {
console.log(`${a} + ${b}`);
return `${a + b}`;
});
defTool(
"divide",
"Use this function to divide two numbers",
{
type: "object",
properties: {
a: {
type: "number",
description: "The first number",
},
b: {
type: "number",
description: "The second number",
},
},
required: ["a", "b"],
},
({ a, b }) => {
console.log(`${a} / ${b}`);
return `${a / b}`;
},
);
$`Answer the following arithmetic question:
${env.vars.question}
`;

Réutilisation des outils dans des scripts système

Section intitulée « Réutilisation des outils dans des scripts système »

Vous pouvez définir des outils dans un script système et les inclure dans votre script principal comme n’importe quel autre script système ou outil.

system.random.genai.mjs
system({ description: "Random tools" })
export default function (ctx: ChatGenerationContext) {
const { defTool } = ctx
defTool("random", "Generate a random number", {}, () => Math.random())
}
  • Assurez-vous d’utiliser system au lieu de script dans le script système.
random-script.genai.mjs
script({
title: "Random number",
tools: ["random"],
})
$`Generate a random number.

Vous pouvez inclure plusieurs fois le même script système dans un script avec différents paramètres.

script({
system: [
"system.agent_git", // git operations on current repository
{
id: "system.agent_git", // same system script
parameters: { repo: "microsoft/genaiscript" }, // but with new parameters
variant: "genaiscript" // appended to the identifier to keep tool identifiers unique
}
]
})

Model Context Provider (MCP) est un protocole ouvert qui permet une intégration transparente entre les applications LLM et les sources de données et outils externes.

Vous pouvez utiliser des serveurs MCP pour fournir des outils à votre LLM.

defTool({
memory: {
command: "npx",
args: ["-y", "@modelcontextprotocol/server-memory"],
},
})

Voir Outils du protocole Model Context pour plus d’informations.

Certains modèles LLM ne disposent pas de prise en charge intégrée des outils. Pour ces modèles, il est possible d’activer la prise en charge des outils via des invites système. Les performances peuvent être inférieures à celles des outils intégrés, mais il est toujours possible d’utiliser des outils.

La prise en charge des outils est mise en œuvre dans system.tool_calls et “apprend” au LLM comment appeler des outils. Lorsque ce mode est activé, vous verrez les jetons d’appel d’outil auxquels répond le LLM.

GenAIScript maintient une liste des modèles bien connus qui ne supportent pas les outils, de sorte que cela se produira automatiquement pour ces modèles.

Pour activer ce mode, vous pouvez soit

  • ajouter l’option fallbackTools au script
script({
fallbackTools: true,
})
  • ou ajouter le flag --fallback-tools à la CLI
Fenêtre de terminal
npx genaiscript run ... --fallback-tools

Un outil peut récupérer des données contenant des attaques d’injection d’invite. Par exemple, un outil qui récupère une URL peut renvoyer une page contenant des attaques d’injection d’invite.

Pour éviter cela, vous pouvez activer l’option detectPromptInjection. Cela exécutera vos services d’analyse de sécurité de contenu sur la sortie de l’outil et effacera la réponse si une attaque est détectée.

defTool("fetch", "Fetch a URL", {
url: {
type: "string",
description: "The URL to fetch",
},
}, async (args) => ...,
{
detectPromptInjection: "always",
})

Vous pouvez configurer GenAIScript pour exécuter une validation LLM-as-a-Judge du résultat de l’outil en fonction de la description ou d’une intention personnalisée. La validation LLM-as-a-Judge se produira sur chaque réponse de l’outil en utilisant l’alias de modèle intent, qui est mappé à small par défaut.

L’intention description est une valeur spéciale qui est développée à la description de l’outil.

defTool(
"fetch",
"Gets the live weather",
{
location: "Seattle",
},
async (args) => { ... },
{
intent: "description",
}
)

Pour choisir quels outils inclure dans un script, vous pouvez les regrouper dans des scripts système. Par exemple, l’outil current_weather peut être inclus dans le script system.current_weather.genai.mjs.

script({
title: "Get the current weather",
})
defTool("current_weather", ...)

puis utilisez l’identifiant de l’outil dans le champ tools.

script({
...,
tools: ["current_weather"],
})

Illustrons comment les outils se combinent avec un script de réponses aux questions.

Dans le script ci-dessous, nous ajoutons l’outil retrieval_web_search. Cet outil appellera retrieval.webSearch si nécessaire.

script({
title: "Answer questions",
tool: ["retrieval_web_search"]
})
def("FILES", env.files)
$`Answer the questions in FILES using a web search.
- List a summary of the answers and the sources used to create the answers.

Nous pouvons ensuite appliquer ce script au fichier questions.md ci-dessous.

- What is the weather in Seattle?
- What laws were voted in the USA congress last week?

Après la première requête, le LLM demande d’appeler le web_search pour chaque question. Les réponses de la recherche web sont ensuite ajoutées à l’historique des messages du LLM et la requête est faite à nouveau. La seconde donne le résultat final qui inclut les résultats de la recherche web.

Builtin tools