[{"data":1,"prerenderedAt":1236},["ShallowReactive",2],{"series-\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fbeyond-one-tool-call-at-a-time-introducing-code-mode":3,"series-context-\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers":1042},{"id":4,"title":5,"body":6,"contentId":1027,"date":1028,"description":1029,"extension":1030,"github":1031,"meetTheInstructor":1033,"meta":1034,"navigation":81,"part":60,"path":1035,"rawbody":1036,"robots":1033,"schemaOrg":1033,"seo":1037,"seriesSlug":1038,"sitemap":1039,"stem":1040,"subtitle":1033,"topics":1033,"__hash__":1041},"series\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fbeyond-one-tool-call-at-a-time-introducing-code-mode.md","Au-delà d'un appel d'outil : découvrir le Code Mode",{"type":7,"value":8,"toc":1022},"minimark",[9,25,28,31,34,39,42,45,371,378,388,391,394,398,415,418,421,424,583,587,590,593,596,632,635,646,652,829,833,1006,1015,1018],[10,11,12,13],"p",{},"Les LLM peuvent demander des appels d'outils. Cela paraît évident aujourd'hui, mais ce n'était pas possible au début. ",[14,15,16,17,24],"em",{},"C'est amusant de parler de « début » comme s'il remontait à longtemps, alors que ",[18,19,23],"a",{"href":20,"rel":21},"https:\u002F\u002Fopenai.com\u002Findex\u002Ffunction-calling-and-other-api-updates\u002F",[22],"nofollow","cela ne fait que 3 ans",".",[10,26,27],{},"Souvent appelée « tool calling » ou « function calling », cette capacité permet à un modèle d'interagir avec un système externe. Un LLM peut par exemple lire ou écrire un fichier grâce à un appel d'outil. Sans cette capacité, un modèle peut toujours expliquer et générer du contenu, mais il ne peut pas agir directement sur un système externe.",[10,29,30],{},"Associé à des outils utiles, un modèle peut avancer vers un objectif. Il peut recueillir les informations dont il a besoin et effectuer les actions nécessaires. Une demande claire peut suffire pour une tâche bien délimitée, même si la fiabilité des résultats dépend toujours des outils disponibles, des instructions et des protections en place.",[10,32,33],{},"Nous devons toutefois lui fournir des outils qui lui permettent d'effectuer des actions précises pour notre compte.",[35,36,38],"h2",{"id":37},"ajouter-un-outil-personnalisé-à-chatgpt","Ajouter un outil personnalisé à ChatGPT",[10,40,41],{},"Imaginez que vous utilisez ChatGPT et que vous souhaitez lui permettre de lire les fichiers de votre disque pour fournir des réponses contextualisées. Vous devez lui donner un outil capable de lire les fichiers, mais vous n'avez pas accès à l'implémentation du modèle.",[10,43,44],{},"Du point de vue du code, cela ressemble à ceci :",[46,47,53],"pre",{"className":48,"code":49,"filename":50,"language":51,"meta":52,"style":52},"language-ts shiki shiki-themes github-light github-light github-dark","import OpenAI from 'openai'\n\nconst client = new OpenAI()\n\nconst tools = [\n  {\n    type: 'function',\n    name: 'get_weather',\n    description: 'Get current temperature for a given location.',\n    parameters: {\n      type: 'object',\n      properties: {\n        location: {\n          type: 'string',\n          description: 'City and country e.g. Bogotá, Colombia',\n        },\n      },\n      required: ['location'],\n      additionalProperties: false,\n    },\n    strict: true,\n  },\n]\n\nconst response = await client.responses.create({\n  model: 'gpt-5.5',\n  input: [\n    { role: 'user', content: 'What is the weather like in Paris today?' },\n  ],\n  tools,\n})\n\n\u002F\u002F From the OpenAI Developer documentation: https:\u002F\u002Fdevelopers.openai.com\u002Fapi\u002Fdocs\u002Fguides\u002Ftools?tool-type=function-calling\n","Exemple","ts","",[54,55,56,76,83,106,111,124,130,142,153,164,170,181,187,193,204,215,221,227,239,250,256,267,273,279,284,306,317,323,341,347,353,359,364],"code",{"__ignoreMap":52},[57,58,61,65,69,72],"span",{"class":59,"line":60},"line",1,[57,62,64],{"class":63},"s8jYJ","import",[57,66,68],{"class":67},"sxrX7"," OpenAI ",[57,70,71],{"class":63},"from",[57,73,75],{"class":74},"sIIMD"," 'openai'\n",[57,77,79],{"class":59,"line":78},2,[57,80,82],{"emptyLinePlaceholder":81},true,"\n",[57,84,86,89,93,96,99,103],{"class":59,"line":85},3,[57,87,88],{"class":63},"const",[57,90,92],{"class":91},"sBjJW"," client",[57,94,95],{"class":63}," =",[57,97,98],{"class":63}," new",[57,100,102],{"class":101},"snPdu"," OpenAI",[57,104,105],{"class":67},"()\n",[57,107,109],{"class":59,"line":108},4,[57,110,82],{"emptyLinePlaceholder":81},[57,112,114,116,119,121],{"class":59,"line":113},5,[57,115,88],{"class":63},[57,117,118],{"class":91}," tools",[57,120,95],{"class":63},[57,122,123],{"class":67}," [\n",[57,125,127],{"class":59,"line":126},6,[57,128,129],{"class":67},"  {\n",[57,131,133,136,139],{"class":59,"line":132},7,[57,134,135],{"class":67},"    type: ",[57,137,138],{"class":74},"'function'",[57,140,141],{"class":67},",\n",[57,143,145,148,151],{"class":59,"line":144},8,[57,146,147],{"class":67},"    name: ",[57,149,150],{"class":74},"'get_weather'",[57,152,141],{"class":67},[57,154,156,159,162],{"class":59,"line":155},9,[57,157,158],{"class":67},"    description: ",[57,160,161],{"class":74},"'Get current temperature for a given location.'",[57,163,141],{"class":67},[57,165,167],{"class":59,"line":166},10,[57,168,169],{"class":67},"    parameters: {\n",[57,171,173,176,179],{"class":59,"line":172},11,[57,174,175],{"class":67},"      type: ",[57,177,178],{"class":74},"'object'",[57,180,141],{"class":67},[57,182,184],{"class":59,"line":183},12,[57,185,186],{"class":67},"      properties: {\n",[57,188,190],{"class":59,"line":189},13,[57,191,192],{"class":67},"        location: {\n",[57,194,196,199,202],{"class":59,"line":195},14,[57,197,198],{"class":67},"          type: ",[57,200,201],{"class":74},"'string'",[57,203,141],{"class":67},[57,205,207,210,213],{"class":59,"line":206},15,[57,208,209],{"class":67},"          description: ",[57,211,212],{"class":74},"'City and country e.g. Bogotá, Colombia'",[57,214,141],{"class":67},[57,216,218],{"class":59,"line":217},16,[57,219,220],{"class":67},"        },\n",[57,222,224],{"class":59,"line":223},17,[57,225,226],{"class":67},"      },\n",[57,228,230,233,236],{"class":59,"line":229},18,[57,231,232],{"class":67},"      required: [",[57,234,235],{"class":74},"'location'",[57,237,238],{"class":67},"],\n",[57,240,242,245,248],{"class":59,"line":241},19,[57,243,244],{"class":67},"      additionalProperties: ",[57,246,247],{"class":91},"false",[57,249,141],{"class":67},[57,251,253],{"class":59,"line":252},20,[57,254,255],{"class":67},"    },\n",[57,257,259,262,265],{"class":59,"line":258},21,[57,260,261],{"class":67},"    strict: ",[57,263,264],{"class":91},"true",[57,266,141],{"class":67},[57,268,270],{"class":59,"line":269},22,[57,271,272],{"class":67},"  },\n",[57,274,276],{"class":59,"line":275},23,[57,277,278],{"class":67},"]\n",[57,280,282],{"class":59,"line":281},24,[57,283,82],{"emptyLinePlaceholder":81},[57,285,287,289,292,294,297,300,303],{"class":59,"line":286},25,[57,288,88],{"class":63},[57,290,291],{"class":91}," response",[57,293,95],{"class":63},[57,295,296],{"class":63}," await",[57,298,299],{"class":67}," client.responses.",[57,301,302],{"class":101},"create",[57,304,305],{"class":67},"({\n",[57,307,309,312,315],{"class":59,"line":308},26,[57,310,311],{"class":67},"  model: ",[57,313,314],{"class":74},"'gpt-5.5'",[57,316,141],{"class":67},[57,318,320],{"class":59,"line":319},27,[57,321,322],{"class":67},"  input: [\n",[57,324,326,329,332,335,338],{"class":59,"line":325},28,[57,327,328],{"class":67},"    { role: ",[57,330,331],{"class":74},"'user'",[57,333,334],{"class":67},", content: ",[57,336,337],{"class":74},"'What is the weather like in Paris today?'",[57,339,340],{"class":67}," },\n",[57,342,344],{"class":59,"line":343},29,[57,345,346],{"class":67},"  ],\n",[57,348,350],{"class":59,"line":349},30,[57,351,352],{"class":67},"  tools,\n",[57,354,356],{"class":59,"line":355},31,[57,357,358],{"class":67},"})\n",[57,360,362],{"class":59,"line":361},32,[57,363,82],{"emptyLinePlaceholder":81},[57,365,367],{"class":59,"line":366},33,[57,368,370],{"class":369},"sCsY4","\u002F\u002F From the OpenAI Developer documentation: https:\u002F\u002Fdevelopers.openai.com\u002Fapi\u002Fdocs\u002Fguides\u002Ftools?tool-type=function-calling\n",[10,372,373,374,377],{},"Nous comprenons vite que nous n'avons pas accès à ce ",[54,375,376],{},"client"," dans ChatGPT. Même si nous y avions accès, deux problèmes se poseraient :",[379,380,381,385],"ol",{},[382,383,384],"li",{},"Les personnes qui ne développent pas ne feraient pas ces modifications elles-mêmes.",[382,386,387],{},"Nous devrions les implémenter pour chaque client, comme Claude, VS Code, Dust, etc.",[10,389,390],{},"Un cauchemar pour tout le monde, nous compris.",[10,392,393],{},"C'est là que MCP intervient.",[35,395,397],{"id":396},"mcp-pour-exposer-les-outils-de-manière-uniforme","MCP pour exposer les outils de manière uniforme",[399,400,403],"callout",{"color":401,"icon":402},"info","i-ph-info-duotone",[10,404,405,406,410,411,24],{},"Les principes fondamentaux de MCP sortent du cadre de cette série. Si vous avez besoin d'une introduction au protocole ou à la relation entre un Agent IA et un serveur MCP, commencez par ",[18,407,409],{"href":408},"..\u002Fai-agents-and-mcp-server-teaming-up-for-the-agentic-web","Agents IA et serveur MCP au service du web agentique",", en particulier ",[18,412,414],{"href":413},"..\u002Fai-agents-and-mcp-server-teaming-up-for-the-agentic-web\u002Fmcp-to-provide-additional-capabilities-to-the-ai-agent","son article sur le serveur MCP",[10,416,417],{},"En résumé, MCP est un protocole qui permet à un Agent IA de communiquer avec un serveur. Le serveur peut fournir des capacités supplémentaires à l'Agent, comme l'accès à des outils. L'Agent, appelé client, peut alors utiliser ces outils pour agir au nom de l'utilisateur.",[10,419,420],{},"Concrètement, le serveur expose les outils par l'intermédiaire d'une API uniforme. Le client peut appeler cette API pour connaître les outils disponibles, puis les enregistrer auprès du modèle. Le modèle peut alors appeler ces outils comme s'il s'agissait de fonctions natives. Lorsqu'un outil est appelé, le client envoie la requête au serveur au lieu de l'exécuter en local. Le serveur exécute l'outil et renvoie le résultat au client, qui le transmet ensuite au modèle.",[10,422,423],{},"Du point de vue du code, le client ressemble à ceci :",[46,425,427],{"className":48,"code":426,"filename":50,"language":51,"meta":52,"style":52},"\u002F\u002F This is pseudo-code, not a real implementation.\nconst client = new LlmClient({\n  provider: 'openai',\n})\n\nconst mcpClient = new McpClient({\n  server: 'https:\u002F\u002Fmcp.example.com',\n})\n\nconst tools = await mcpClient.getTools() \u002F\u002F Provide a weather tool, similar to the previous example.\n\nconst response = await client.responses.create({\n  model: 'gpt-5.5',\n  input: [\n    { role: 'user', content: 'What is the weather like in Paris today?' },\n  ],\n  tools, \u002F\u002F The tools are now provided by the MCP server, not hardcoded in the client.\n})\n",[54,428,429,434,449,459,463,467,483,493,497,501,523,527,543,551,555,567,571,579],{"__ignoreMap":52},[57,430,431],{"class":59,"line":60},[57,432,433],{"class":369},"\u002F\u002F This is pseudo-code, not a real implementation.\n",[57,435,436,438,440,442,444,447],{"class":59,"line":78},[57,437,88],{"class":63},[57,439,92],{"class":91},[57,441,95],{"class":63},[57,443,98],{"class":63},[57,445,446],{"class":101}," LlmClient",[57,448,305],{"class":67},[57,450,451,454,457],{"class":59,"line":85},[57,452,453],{"class":67},"  provider: ",[57,455,456],{"class":74},"'openai'",[57,458,141],{"class":67},[57,460,461],{"class":59,"line":108},[57,462,358],{"class":67},[57,464,465],{"class":59,"line":113},[57,466,82],{"emptyLinePlaceholder":81},[57,468,469,471,474,476,478,481],{"class":59,"line":126},[57,470,88],{"class":63},[57,472,473],{"class":91}," mcpClient",[57,475,95],{"class":63},[57,477,98],{"class":63},[57,479,480],{"class":101}," McpClient",[57,482,305],{"class":67},[57,484,485,488,491],{"class":59,"line":132},[57,486,487],{"class":67},"  server: ",[57,489,490],{"class":74},"'https:\u002F\u002Fmcp.example.com'",[57,492,141],{"class":67},[57,494,495],{"class":59,"line":144},[57,496,358],{"class":67},[57,498,499],{"class":59,"line":155},[57,500,82],{"emptyLinePlaceholder":81},[57,502,503,505,507,509,511,514,517,520],{"class":59,"line":166},[57,504,88],{"class":63},[57,506,118],{"class":91},[57,508,95],{"class":63},[57,510,296],{"class":63},[57,512,513],{"class":67}," mcpClient.",[57,515,516],{"class":101},"getTools",[57,518,519],{"class":67},"() ",[57,521,522],{"class":369},"\u002F\u002F Provide a weather tool, similar to the previous example.\n",[57,524,525],{"class":59,"line":172},[57,526,82],{"emptyLinePlaceholder":81},[57,528,529,531,533,535,537,539,541],{"class":59,"line":183},[57,530,88],{"class":63},[57,532,291],{"class":91},[57,534,95],{"class":63},[57,536,296],{"class":63},[57,538,299],{"class":67},[57,540,302],{"class":101},[57,542,305],{"class":67},[57,544,545,547,549],{"class":59,"line":189},[57,546,311],{"class":67},[57,548,314],{"class":74},[57,550,141],{"class":67},[57,552,553],{"class":59,"line":195},[57,554,322],{"class":67},[57,556,557,559,561,563,565],{"class":59,"line":206},[57,558,328],{"class":67},[57,560,331],{"class":74},[57,562,334],{"class":67},[57,564,337],{"class":74},[57,566,340],{"class":67},[57,568,569],{"class":59,"line":217},[57,570,346],{"class":67},[57,572,573,576],{"class":59,"line":223},[57,574,575],{"class":67},"  tools, ",[57,577,578],{"class":369},"\u002F\u002F The tools are now provided by the MCP server, not hardcoded in the client.\n",[57,580,581],{"class":59,"line":229},[57,582,358],{"class":67},[35,584,586],{"id":585},"dépendance-entre-les-appels-doutils","Dépendance entre les appels d'outils",[10,588,589],{},"Avec cette approche, le modèle reçoit le résultat de chaque outil avant de pouvoir décider de la suite. Si une action nécessite trois appels d'outils dépendants, le modèle a besoin de trois tours, et les résultats intermédiaires rejoignent son contexte.",[10,591,592],{},"Soyons honnêtes, cela fonctionne très bien la plupart du temps. Ce n'est toutefois pas optimal dans tous les cas.",[10,594,595],{},"Avec le serveur MCP dans la boucle, la chaîne d'événements ressemble à ceci :",[379,597,598,601,604,607,610,617,620,623,626,629],{},[382,599,600],{},"Le client MCP se connecte au serveur MCP.",[382,602,603],{},"Le client MCP demande au serveur MCP la liste des outils disponibles.",[382,605,606],{},"Le serveur MCP renvoie la liste des outils disponibles au client MCP.",[382,608,609],{},"Le client MCP enregistre les outils auprès du modèle.",[382,611,612,613,616],{},"Le modèle appelle un outil, par exemple ",[54,614,615],{},"get_weather",", avec les paramètres requis.",[382,618,619],{},"Le client MCP reçoit la demande d'appel d'outil du modèle.",[382,621,622],{},"Le client MCP envoie la demande d'appel d'outil au serveur MCP.",[382,624,625],{},"Le serveur MCP exécute l'outil, par exemple en récupérant la météo du lieu indiqué.",[382,627,628],{},"Le serveur MCP renvoie le résultat de l'exécution au client MCP.",[382,630,631],{},"Le client MCP renvoie le résultat de l'exécution au modèle.",[10,633,634],{},"La bonne nouvelle, et la raison pour laquelle nous parlons d'une approche « uniforme », est que toutes les étapes liées à MCP restent identiques pour chaque client et chaque serveur MCP. Vous n'avez qu'à vous concentrer sur l'implémentation de l'outil.",[10,636,637,638,641,642,645],{},"Imaginez maintenant le contexte suivant. Vous travaillez sur un Drive qui contient de nombreux fichiers Markdown. Votre Agent est connecté à ce Drive grâce à un MCP qui propose deux outils : ",[54,639,640],{},"readFile"," et ",[54,643,644],{},"writeFile",". Votre objectif est de créer un fichier qui contient tous les titres d'un fichier Markdown.",[10,647,648,649,651],{},"L'outil ",[54,650,640],{}," est défini comme suit dans le serveur MCP :",[46,653,655],{"className":48,"code":654,"filename":50,"language":51,"meta":52,"style":52},"server.registerTool(\n  'readFile',\n  {\n    title: 'Drive Read File',\n    description: 'Read a Markdown file from the local Drive fixture.',\n    inputSchema: z.object({\n      path: z.string().min(1)\n    }),\n    annotations: {\n      title: 'Drive Read File',\n      readOnlyHint: true\n    }\n  },\n  async ({ path }) => {\n    const content = await readDriveFile(path)\n    return { content: [{ type: 'text', text: content }] }\n  }\n)\n",[54,656,657,668,675,679,689,698,708,731,736,741,750,758,763,767,788,806,820,825],{"__ignoreMap":52},[57,658,659,662,665],{"class":59,"line":60},[57,660,661],{"class":67},"server.",[57,663,664],{"class":101},"registerTool",[57,666,667],{"class":67},"(\n",[57,669,670,673],{"class":59,"line":78},[57,671,672],{"class":74},"  'readFile'",[57,674,141],{"class":67},[57,676,677],{"class":59,"line":85},[57,678,129],{"class":67},[57,680,681,684,687],{"class":59,"line":108},[57,682,683],{"class":67},"    title: ",[57,685,686],{"class":74},"'Drive Read File'",[57,688,141],{"class":67},[57,690,691,693,696],{"class":59,"line":113},[57,692,158],{"class":67},[57,694,695],{"class":74},"'Read a Markdown file from the local Drive fixture.'",[57,697,141],{"class":67},[57,699,700,703,706],{"class":59,"line":126},[57,701,702],{"class":67},"    inputSchema: z.",[57,704,705],{"class":101},"object",[57,707,305],{"class":67},[57,709,710,713,716,719,722,725,728],{"class":59,"line":132},[57,711,712],{"class":67},"      path: z.",[57,714,715],{"class":101},"string",[57,717,718],{"class":67},"().",[57,720,721],{"class":101},"min",[57,723,724],{"class":67},"(",[57,726,727],{"class":91},"1",[57,729,730],{"class":67},")\n",[57,732,733],{"class":59,"line":144},[57,734,735],{"class":67},"    }),\n",[57,737,738],{"class":59,"line":155},[57,739,740],{"class":67},"    annotations: {\n",[57,742,743,746,748],{"class":59,"line":166},[57,744,745],{"class":67},"      title: ",[57,747,686],{"class":74},[57,749,141],{"class":67},[57,751,752,755],{"class":59,"line":172},[57,753,754],{"class":67},"      readOnlyHint: ",[57,756,757],{"class":91},"true\n",[57,759,760],{"class":59,"line":183},[57,761,762],{"class":67},"    }\n",[57,764,765],{"class":59,"line":189},[57,766,272],{"class":67},[57,768,769,772,775,779,782,785],{"class":59,"line":195},[57,770,771],{"class":63},"  async",[57,773,774],{"class":67}," ({ ",[57,776,778],{"class":777},"sP4rz","path",[57,780,781],{"class":67}," }) ",[57,783,784],{"class":63},"=>",[57,786,787],{"class":67}," {\n",[57,789,790,793,796,798,800,803],{"class":59,"line":206},[57,791,792],{"class":63},"    const",[57,794,795],{"class":91}," content",[57,797,95],{"class":63},[57,799,296],{"class":63},[57,801,802],{"class":101}," readDriveFile",[57,804,805],{"class":67},"(path)\n",[57,807,808,811,814,817],{"class":59,"line":217},[57,809,810],{"class":63},"    return",[57,812,813],{"class":67}," { content: [{ type: ",[57,815,816],{"class":74},"'text'",[57,818,819],{"class":67},", text: content }] }\n",[57,821,822],{"class":59,"line":223},[57,823,824],{"class":67},"  }\n",[57,826,827],{"class":59,"line":229},[57,828,730],{"class":67},[10,830,648,831,651],{},[54,832,644],{},[46,834,836],{"className":48,"code":835,"filename":50,"language":51,"meta":52,"style":52},"server.registerTool(\n  'writeFile',\n  {\n    title: 'Drive Write File',\n    description: 'Write a Markdown file to the local Drive fixture.',\n    inputSchema: z.object({\n      path: z.string().min(1),\n      content: z.string()\n    }),\n    annotations: {\n      title: 'Drive Write File',\n      destructiveHint: true\n    }\n  },\n  async ({ path, content }) => {\n    await writeDriveFile(path, content)\n    return { content: [{ type: 'text', text: JSON.stringify({ success: true }) }] }\n  }\n)\n",[54,837,838,846,853,857,866,875,883,900,909,913,917,925,932,936,940,960,971,998,1002],{"__ignoreMap":52},[57,839,840,842,844],{"class":59,"line":60},[57,841,661],{"class":67},[57,843,664],{"class":101},[57,845,667],{"class":67},[57,847,848,851],{"class":59,"line":78},[57,849,850],{"class":74},"  'writeFile'",[57,852,141],{"class":67},[57,854,855],{"class":59,"line":85},[57,856,129],{"class":67},[57,858,859,861,864],{"class":59,"line":108},[57,860,683],{"class":67},[57,862,863],{"class":74},"'Drive Write File'",[57,865,141],{"class":67},[57,867,868,870,873],{"class":59,"line":113},[57,869,158],{"class":67},[57,871,872],{"class":74},"'Write a Markdown file to the local Drive fixture.'",[57,874,141],{"class":67},[57,876,877,879,881],{"class":59,"line":126},[57,878,702],{"class":67},[57,880,705],{"class":101},[57,882,305],{"class":67},[57,884,885,887,889,891,893,895,897],{"class":59,"line":132},[57,886,712],{"class":67},[57,888,715],{"class":101},[57,890,718],{"class":67},[57,892,721],{"class":101},[57,894,724],{"class":67},[57,896,727],{"class":91},[57,898,899],{"class":67},"),\n",[57,901,902,905,907],{"class":59,"line":144},[57,903,904],{"class":67},"      content: z.",[57,906,715],{"class":101},[57,908,105],{"class":67},[57,910,911],{"class":59,"line":155},[57,912,735],{"class":67},[57,914,915],{"class":59,"line":166},[57,916,740],{"class":67},[57,918,919,921,923],{"class":59,"line":172},[57,920,745],{"class":67},[57,922,863],{"class":74},[57,924,141],{"class":67},[57,926,927,930],{"class":59,"line":183},[57,928,929],{"class":67},"      destructiveHint: ",[57,931,757],{"class":91},[57,933,934],{"class":59,"line":189},[57,935,762],{"class":67},[57,937,938],{"class":59,"line":195},[57,939,272],{"class":67},[57,941,942,944,946,948,951,954,956,958],{"class":59,"line":206},[57,943,771],{"class":63},[57,945,774],{"class":67},[57,947,778],{"class":777},[57,949,950],{"class":67},", ",[57,952,953],{"class":777},"content",[57,955,781],{"class":67},[57,957,784],{"class":63},[57,959,787],{"class":67},[57,961,962,965,968],{"class":59,"line":217},[57,963,964],{"class":63},"    await",[57,966,967],{"class":101}," writeDriveFile",[57,969,970],{"class":67},"(path, content)\n",[57,972,973,975,977,979,982,985,987,990,993,995],{"class":59,"line":223},[57,974,810],{"class":63},[57,976,813],{"class":67},[57,978,816],{"class":74},[57,980,981],{"class":67},", text: ",[57,983,984],{"class":91},"JSON",[57,986,24],{"class":67},[57,988,989],{"class":101},"stringify",[57,991,992],{"class":67},"({ success: ",[57,994,264],{"class":91},[57,996,997],{"class":67}," }) }] }\n",[57,999,1000],{"class":59,"line":229},[57,1001,824],{"class":67},[57,1003,1004],{"class":59,"line":241},[57,1005,730],{"class":67},[10,1007,1008,1009,1011,1012,1014],{},"Avec l'approche MCP actuelle, le modèle doit appeler ",[54,1010,640],{}," pour lire le fichier, charger son contenu dans son contexte, en extraire les titres, puis appeler ",[54,1013,644],{}," pour écrire ces titres dans un nouveau fichier. Le modèle doit donc charger l'intégralité du fichier dans son contexte. Celui-ci peut être très volumineux et provoquer un dépassement de contexte, une injection de prompt et des coûts inutiles en jetons, sans aucune garantie que le modèle extraira correctement les titres.",[10,1016,1017],{},"C'est précisément dans ce cas que le Code Mode montre son intérêt. Dans le prochain article, nous transformerons ce serveur MCP en serveur Code Mode. Nous verrons comment le modèle peut orchestrer les appels d'outils sans charger l'intégralité du contenu dans son contexte.",[1019,1020,1021],"style",{},"html pre.shiki code .s8jYJ, html code.shiki .s8jYJ{--shiki-light:#D73A49;--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sxrX7, html code.shiki .sxrX7{--shiki-light:#24292E;--shiki-default:#24292E;--shiki-dark:#E1E4E8}html pre.shiki code .sIIMD, html code.shiki .sIIMD{--shiki-light:#032F62;--shiki-default:#032F62;--shiki-dark:#9ECBFF}html pre.shiki code .sBjJW, html code.shiki .sBjJW{--shiki-light:#005CC5;--shiki-default:#005CC5;--shiki-dark:#79B8FF}html pre.shiki code .snPdu, html code.shiki .snPdu{--shiki-light:#6F42C1;--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .sCsY4, html code.shiki .sCsY4{--shiki-light:#6A737D;--shiki-default:#6A737D;--shiki-dark:#6A737D}html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sP4rz, html code.shiki .sP4rz{--shiki-light:#E36209;--shiki-default:#E36209;--shiki-dark:#FFAB70}",{"title":52,"searchDepth":78,"depth":78,"links":1023},[1024,1025,1026],{"id":37,"depth":78,"text":38},{"id":396,"depth":78,"text":397},{"id":585,"depth":78,"text":586},"02726224-2677-4d4b-9390-cf6543caba80","2026-07-12","Découvrez pourquoi les appels d'outils MCP dépendants remplissent le contexte du modèle et comment le Code Mode déplace leur orchestration dans le code.","md",{"branch":1032},"part-1-direct-tools",null,{},"\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fbeyond-one-tool-call-at-a-time-introducing-code-mode","---\ncontentId: 02726224-2677-4d4b-9390-cf6543caba80\npart: 1\ntitle: \"Au-delà d'un appel d'outil : découvrir le Code Mode\"\ndescription: Découvrez pourquoi les appels d'outils MCP dépendants remplissent le contexte du modèle et comment le Code Mode déplace leur orchestration dans le code.\ngithub:\n  branch: part-1-direct-tools\ndate: 2026-07-12\nseriesSlug: building-code-mode-for-apis-with-mcp-and-isolated-workers\n---\n\nLes LLM peuvent demander des appels d'outils. Cela paraît évident aujourd'hui, mais ce n'était pas possible au début. _C'est amusant de parler de « début » comme s'il remontait à longtemps, alors que [cela ne fait que 3 ans](https:\u002F\u002Fopenai.com\u002Findex\u002Ffunction-calling-and-other-api-updates\u002F)._\n\nSouvent appelée « tool calling » ou « function calling », cette capacité permet à un modèle d'interagir avec un système externe. Un LLM peut par exemple lire ou écrire un fichier grâce à un appel d'outil. Sans cette capacité, un modèle peut toujours expliquer et générer du contenu, mais il ne peut pas agir directement sur un système externe.\n\nAssocié à des outils utiles, un modèle peut avancer vers un objectif. Il peut recueillir les informations dont il a besoin et effectuer les actions nécessaires. Une demande claire peut suffire pour une tâche bien délimitée, même si la fiabilité des résultats dépend toujours des outils disponibles, des instructions et des protections en place.\n\nNous devons toutefois lui fournir des outils qui lui permettent d'effectuer des actions précises pour notre compte.\n\n## Ajouter un outil personnalisé à ChatGPT\n\nImaginez que vous utilisez ChatGPT et que vous souhaitez lui permettre de lire les fichiers de votre disque pour fournir des réponses contextualisées. Vous devez lui donner un outil capable de lire les fichiers, mais vous n'avez pas accès à l'implémentation du modèle.\n\nDu point de vue du code, cela ressemble à ceci :\n\n```ts [Exemple]\nimport OpenAI from 'openai'\n\nconst client = new OpenAI()\n\nconst tools = [\n  {\n    type: 'function',\n    name: 'get_weather',\n    description: 'Get current temperature for a given location.',\n    parameters: {\n      type: 'object',\n      properties: {\n        location: {\n          type: 'string',\n          description: 'City and country e.g. Bogotá, Colombia',\n        },\n      },\n      required: ['location'],\n      additionalProperties: false,\n    },\n    strict: true,\n  },\n]\n\nconst response = await client.responses.create({\n  model: 'gpt-5.5',\n  input: [\n    { role: 'user', content: 'What is the weather like in Paris today?' },\n  ],\n  tools,\n})\n\n\u002F\u002F From the OpenAI Developer documentation: https:\u002F\u002Fdevelopers.openai.com\u002Fapi\u002Fdocs\u002Fguides\u002Ftools?tool-type=function-calling\n```\n\nNous comprenons vite que nous n'avons pas accès à ce `client` dans ChatGPT. Même si nous y avions accès, deux problèmes se poseraient :\n\n1. Les personnes qui ne développent pas ne feraient pas ces modifications elles-mêmes.\n2. Nous devrions les implémenter pour chaque client, comme Claude, VS Code, Dust, etc.\n\nUn cauchemar pour tout le monde, nous compris.\n\nC'est là que MCP intervient.\n\n## MCP pour exposer les outils de manière uniforme\n\n::callout{icon=\"i-ph-info-duotone\" color=\"info\"}\nLes principes fondamentaux de MCP sortent du cadre de cette série. Si vous avez besoin d'une introduction au protocole ou à la relation entre un Agent IA et un serveur MCP, commencez par [Agents IA et serveur MCP au service du web agentique](..\u002Fai-agents-and-mcp-server-teaming-up-for-the-agentic-web.md), en particulier [son article sur le serveur MCP](..\u002Fai-agents-and-mcp-server-teaming-up-for-the-agentic-web\u002Fmcp-to-provide-additional-capabilities-to-the-ai-agent.md).\n::\n\nEn résumé, MCP est un protocole qui permet à un Agent IA de communiquer avec un serveur. Le serveur peut fournir des capacités supplémentaires à l'Agent, comme l'accès à des outils. L'Agent, appelé client, peut alors utiliser ces outils pour agir au nom de l'utilisateur.\n\nConcrètement, le serveur expose les outils par l'intermédiaire d'une API uniforme. Le client peut appeler cette API pour connaître les outils disponibles, puis les enregistrer auprès du modèle. Le modèle peut alors appeler ces outils comme s'il s'agissait de fonctions natives. Lorsqu'un outil est appelé, le client envoie la requête au serveur au lieu de l'exécuter en local. Le serveur exécute l'outil et renvoie le résultat au client, qui le transmet ensuite au modèle.\n\nDu point de vue du code, le client ressemble à ceci :\n\n```ts [Exemple]\n\u002F\u002F This is pseudo-code, not a real implementation.\nconst client = new LlmClient({\n  provider: 'openai',\n})\n\nconst mcpClient = new McpClient({\n  server: 'https:\u002F\u002Fmcp.example.com',\n})\n\nconst tools = await mcpClient.getTools() \u002F\u002F Provide a weather tool, similar to the previous example.\n\nconst response = await client.responses.create({\n  model: 'gpt-5.5',\n  input: [\n    { role: 'user', content: 'What is the weather like in Paris today?' },\n  ],\n  tools, \u002F\u002F The tools are now provided by the MCP server, not hardcoded in the client.\n})\n```\n\n## Dépendance entre les appels d'outils\n\nAvec cette approche, le modèle reçoit le résultat de chaque outil avant de pouvoir décider de la suite. Si une action nécessite trois appels d'outils dépendants, le modèle a besoin de trois tours, et les résultats intermédiaires rejoignent son contexte.\n\nSoyons honnêtes, cela fonctionne très bien la plupart du temps. Ce n'est toutefois pas optimal dans tous les cas.\n\nAvec le serveur MCP dans la boucle, la chaîne d'événements ressemble à ceci :\n\n1. Le client MCP se connecte au serveur MCP.\n2. Le client MCP demande au serveur MCP la liste des outils disponibles.\n3. Le serveur MCP renvoie la liste des outils disponibles au client MCP.\n4. Le client MCP enregistre les outils auprès du modèle.\n5. Le modèle appelle un outil, par exemple `get_weather`, avec les paramètres requis.\n6. Le client MCP reçoit la demande d'appel d'outil du modèle.\n7. Le client MCP envoie la demande d'appel d'outil au serveur MCP.\n8. Le serveur MCP exécute l'outil, par exemple en récupérant la météo du lieu indiqué.\n9. Le serveur MCP renvoie le résultat de l'exécution au client MCP.\n10. Le client MCP renvoie le résultat de l'exécution au modèle.\n\nLa bonne nouvelle, et la raison pour laquelle nous parlons d'une approche « uniforme », est que toutes les étapes liées à MCP restent identiques pour chaque client et chaque serveur MCP. Vous n'avez qu'à vous concentrer sur l'implémentation de l'outil.\n\nImaginez maintenant le contexte suivant. Vous travaillez sur un Drive qui contient de nombreux fichiers Markdown. Votre Agent est connecté à ce Drive grâce à un MCP qui propose deux outils : `readFile` et `writeFile`. Votre objectif est de créer un fichier qui contient tous les titres d'un fichier Markdown.\n\nL'outil `readFile` est défini comme suit dans le serveur MCP :\n\n```ts [Exemple]\nserver.registerTool(\n  'readFile',\n  {\n    title: 'Drive Read File',\n    description: 'Read a Markdown file from the local Drive fixture.',\n    inputSchema: z.object({\n      path: z.string().min(1)\n    }),\n    annotations: {\n      title: 'Drive Read File',\n      readOnlyHint: true\n    }\n  },\n  async ({ path }) => {\n    const content = await readDriveFile(path)\n    return { content: [{ type: 'text', text: content }] }\n  }\n)\n```\n\nL'outil `writeFile` est défini comme suit dans le serveur MCP :\n\n```ts [Exemple]\nserver.registerTool(\n  'writeFile',\n  {\n    title: 'Drive Write File',\n    description: 'Write a Markdown file to the local Drive fixture.',\n    inputSchema: z.object({\n      path: z.string().min(1),\n      content: z.string()\n    }),\n    annotations: {\n      title: 'Drive Write File',\n      destructiveHint: true\n    }\n  },\n  async ({ path, content }) => {\n    await writeDriveFile(path, content)\n    return { content: [{ type: 'text', text: JSON.stringify({ success: true }) }] }\n  }\n)\n```\n\nAvec l'approche MCP actuelle, le modèle doit appeler `readFile` pour lire le fichier, charger son contenu dans son contexte, en extraire les titres, puis appeler `writeFile` pour écrire ces titres dans un nouveau fichier. Le modèle doit donc charger l'intégralité du fichier dans son contexte. Celui-ci peut être très volumineux et provoquer un dépassement de contexte, une injection de prompt et des coûts inutiles en jetons, sans aucune garantie que le modèle extraira correctement les titres.\n\nC'est précisément dans ce cas que le Code Mode montre son intérêt. Dans le prochain article, nous transformerons ce serveur MCP en serveur Code Mode. Nous verrons comment le modèle peut orchestrer les appels d'outils sans charger l'intégralité du contenu dans son contexte.\n",{"title":5,"description":1029},"building-code-mode-for-apis-with-mcp-and-isolated-workers",{"loc":1035},"fr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fbeyond-one-tool-call-at-a-time-introducing-code-mode","uXGqy38aGuELJWWH0l0Usi3rbiIMFYL_VQLkrlQ1buw",{"overview":1043,"chapters":1206},{"id":1044,"title":1045,"body":1046,"contentId":1185,"date":1028,"description":1186,"extension":1030,"github":1187,"meetTheInstructor":1189,"meta":1190,"navigation":81,"part":1033,"path":1191,"rawbody":1192,"robots":1033,"schemaOrg":1033,"seo":1193,"seriesSlug":1038,"sitemap":1194,"stem":1195,"subtitle":1196,"topics":1197,"__hash__":1205},"series\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers.md","Construire le Code Mode pour les API avec MCP et Workers",{"type":7,"value":1047,"toc":1182},[1048,1051,1059,1066,1074,1090,1093,1096,1099,1156,1164,1172,1176],[10,1049,1050],{},"Bonjour et bienvenue ! 👋",[10,1052,1053,1054,1058],{},"Cette série prolonge de manière concrète l'article ",[18,1055,1057],{"href":1056},"\u002Ffr\u002Fposts\u002Fcode-mode-two-tools-and-an-mcp-can-save-your-llm-context","Code Mode, deux outils et un MCP peuvent préserver le contexte de votre LLM",". Celui-ci présentait l'idée suivante : au lieu de demander à un modèle d'orchestrer chaque appel d'outil dépendant, laissons-le écrire cette orchestration sous forme de code et renvoyer uniquement le résultat nécessaire à sa prochaine décision.",[10,1060,1061,1062,1065],{},"Ici, nous allons construire cette approche étape par étape. Nous commencerons par une petite transformation de fichier en local, puis nous passerons à une API décrite avec OpenAPI avant de remplacer l'évaluateur local de confiance basé sur le constructeur ",[54,1063,1064],{},"Function"," par un environnement d'exécution isolé. Nous obtiendrons un serveur MCP exécutable en local, capable de rechercher dans la spécification d'une API et d'exécuter une requête ciblée vers cette API.",[10,1067,405,1068,410,1071,24],{},[18,1069,409],{"href":1070},"\u002Ffr\u002Fseries\u002Fai-agents-and-mcp-server-teaming-up-for-the-agentic-web",[18,1072,414],{"href":1073},"\u002Ffr\u002Fseries\u002Fai-agents-and-mcp-server-teaming-up-for-the-agentic-web\u002Fmcp-to-provide-additional-capabilities-to-the-ai-agent",[10,1075,1076,1077,1081,1082,1085,1086,1089],{},"Tout au long de la série, le ",[1078,1079,1080],"strong",{},"modèle"," génère des appels d'outils ou du code, le ",[1078,1083,1084],{},"client MCP"," ou Agent exécute la boucle du modèle et le ",[1078,1087,1088],{},"serveur MCP"," fournit les capacités. Il faut bien distinguer ces rôles : l'hôte, et non le code généré, définit les capacités disponibles.",[10,1091,1092],{},"L'idée centrale est simple. Avec des outils MCP directs, le modèle doit appeler un outil, recevoir l'intégralité du résultat intermédiaire, puis utiliser ce résultat pour décider comment appeler l'outil suivant. Avec le Code Mode, le modèle écrit l'orchestration sous forme de code. Ce code accède aux capacités dont il a besoin dans l'environnement d'exécution, et le modèle reçoit uniquement le résultat final souhaité pour poursuivre son travail.",[10,1094,1095],{},"Le Code Mode n'est pas toujours le bon choix. Les outils MCP directs restent plus simples pour les actions courtes et évidentes. L'environnement d'exécution supplémentaire devient utile lorsqu'une tâche comporte des appels dépendants, nécessite un traitement local des données ou doit parcourir une API vaste et évolutive. C'est par exemple le cas d'une spécification OpenAPI qui peut dépasser la fenêtre de contexte du modèle.",[10,1097,1098],{},"Au fil de cette série, nous allons :",[379,1100,1101,1111,1126,1136,1150],{},[382,1102,1103,1106,1107,1110],{},[1078,1104,1105],{},"Au-delà d'un appel d'outil à la fois : découvrir le Code Mode"," : construire deux outils ",[54,1108,1109],{},"Drive"," directs autour d'un fichier Markdown de test et observer comment l'intégralité de son contenu traverse le contexte du modèle avant l'appel d'outil suivant.",[382,1112,1113,1116,1117,1119,1120,1122,1123,1125],{},[1078,1114,1115],{},"Laisser le modèle orchestrer les outils dans un environnement local"," : remplacer les deux outils directs par un outil ",[54,1118,54],{}," générique, exposer une façade ",[54,1121,1109],{}," typée et introduire l'interface de l'exécuteur que les parties suivantes remplaceront. L'évaluateur local basé sur le constructeur ",[54,1124,1064],{}," est volontairement un raccourci réservé au développement de confiance, et non un bac à sable de production.",[382,1127,1128,1131,1132,1135],{},[1078,1129,1130],{},"Rechercher dans une spécification OpenAPI sans remplir le contexte"," : conserver le document OpenAPI dans le serveur, résoudre ses références ",[54,1133,1134],{},"$ref"," locales et laisser le code généré effectuer ses recherches dans une façade de types compacte au lieu de renvoyer toute la spécification au modèle.",[382,1137,1138,1141,1142,1145,1146,1149],{},[1078,1139,1140],{},"Appeler des API avec le Code Mode et ne renvoyer que l'essentiel"," : ajouter un outil ",[54,1143,1144],{},"execute"," distinct avec une fonction ",[54,1147,1148],{},"api.request()"," contrôlée par l'hôte. Nous validerons les options de la requête, appellerons l'API MarketHub locale utilisée pour les tests et renverrons une projection ciblée plutôt que la réponse complète de l'API.",[382,1151,1152,1155],{},[1078,1153,1154],{},"Remplacer l'évaluateur par des Workers Cloudflare isolés"," : remplacer uniquement l'exécuteur par de nouveaux Workers dynamiques. La recherche s'exécutera sans accès sortant, tandis que les appels passeront par une passerelle avec une liste d'autorisations. Les identifiants resteront hors du code généré. Nous aborderons également les limites des résultats, les limites de ressources et les délais imposés par l'hôte.",[10,1157,1158,1159,1163],{},"Le dépôt associé, ",[1160,1161],"git-hub-link",{"repo":1162},"barbapapazes\u002Fcode-mode",", est un manuel exécutable pour cette série. Chaque article dispose d'une branche qui représente un état complet, d'une petite évaluation et d'un diff ciblé par rapport à l'étape précédente. Je vous recommande d'extraire une branche et d'étudier l'implémentation pour mieux comprendre les concepts, car les articles ne couvriront pas chaque détail.",[399,1165,1166],{"color":401,"icon":402},[10,1167,1168,1169,1171],{},"Cette série suppose que vous connaissez TypeScript, les promesses JavaScript, les API HTTP et les concepts de base de MCP. Les étapes locales ne contiennent aucun identifiant. Les parties 2 à 4 utilisent un évaluateur local de confiance basé sur le constructeur ",[54,1170,1064],{}," pour le développement. La partie 5 fournit une base de déploiement Cloudflare et une évaluation structurelle de la sécurité.",[35,1173,1175],{"id":1174},"chapitres","Chapitres",[1177,1178],"series-chapters-list",{"className":1179},[1180,1181],"mx-auto","max-w-5xl",{"title":52,"searchDepth":78,"depth":78,"links":1183},[1184],{"id":1174,"depth":78,"text":1175},"4fc50be1-a524-474e-8426-392581f8b0e8","Construisez un serveur MCP pour une API décrite par OpenAPI, puis remplacez l'évaluateur local par des Workers Cloudflare isolés.",{"name":1188,"repository":1162},"Code Mode","J'ai créé cette série pour transformer l'idée du Code Mode en une implémentation concrète. Nous commencerons avec deux outils MCP ordinaires, puis nous confierons l'orchestration au code généré avant de remplacer un évaluateur local de confiance basé sur le constructeur Function par des Workers Cloudflare dynamiques et isolés.",{},"\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers","---\ncontentId: 4fc50be1-a524-474e-8426-392581f8b0e8\ntitle: Construire le Code Mode pour les API avec MCP et Workers\nsubtitle: Créez un serveur MCP économe en contexte pour les API décrites avec OpenAPI\ndescription: Construisez un serveur MCP pour une API décrite par OpenAPI, puis remplacez l'évaluateur local par des Workers Cloudflare isolés.\ndate: 2026-07-12\ntopics:\n  - ai\n  - ai-agents\n  - mcp\n  - code-mode\n  - openapi\n  - cloudflare\n  - typescript\ngithub:\n  name: Code Mode\n  repository: barbapapazes\u002Fcode-mode\nmeetTheInstructor: J'ai créé cette série pour transformer l'idée du Code Mode en une implémentation concrète. Nous commencerons avec deux outils MCP ordinaires, puis nous confierons l'orchestration au code généré avant de remplacer un évaluateur local de confiance basé sur le constructeur Function par des Workers Cloudflare dynamiques et isolés.\nseriesSlug: building-code-mode-for-apis-with-mcp-and-isolated-workers\n---\n\nBonjour et bienvenue ! 👋\n\nCette série prolonge de manière concrète l'article [Code Mode, deux outils et un MCP peuvent préserver le contexte de votre LLM](\u002Ffr\u002Fposts\u002Fcode-mode-two-tools-and-an-mcp-can-save-your-llm-context). Celui-ci présentait l'idée suivante : au lieu de demander à un modèle d'orchestrer chaque appel d'outil dépendant, laissons-le écrire cette orchestration sous forme de code et renvoyer uniquement le résultat nécessaire à sa prochaine décision.\n\nIci, nous allons construire cette approche étape par étape. Nous commencerons par une petite transformation de fichier en local, puis nous passerons à une API décrite avec OpenAPI avant de remplacer l'évaluateur local de confiance basé sur le constructeur `Function` par un environnement d'exécution isolé. Nous obtiendrons un serveur MCP exécutable en local, capable de rechercher dans la spécification d'une API et d'exécuter une requête ciblée vers cette API.\n\nLes principes fondamentaux de MCP sortent du cadre de cette série. Si vous avez besoin d'une introduction au protocole ou à la relation entre un Agent IA et un serveur MCP, commencez par [Agents IA et serveur MCP au service du web agentique](\u002Ffr\u002Fseries\u002Fai-agents-and-mcp-server-teaming-up-for-the-agentic-web), en particulier [son article sur le serveur MCP](\u002Ffr\u002Fseries\u002Fai-agents-and-mcp-server-teaming-up-for-the-agentic-web\u002Fmcp-to-provide-additional-capabilities-to-the-ai-agent).\n\nTout au long de la série, le **modèle** génère des appels d'outils ou du code, le **client MCP** ou Agent exécute la boucle du modèle et le **serveur MCP** fournit les capacités. Il faut bien distinguer ces rôles : l'hôte, et non le code généré, définit les capacités disponibles.\n\nL'idée centrale est simple. Avec des outils MCP directs, le modèle doit appeler un outil, recevoir l'intégralité du résultat intermédiaire, puis utiliser ce résultat pour décider comment appeler l'outil suivant. Avec le Code Mode, le modèle écrit l'orchestration sous forme de code. Ce code accède aux capacités dont il a besoin dans l'environnement d'exécution, et le modèle reçoit uniquement le résultat final souhaité pour poursuivre son travail.\n\nLe Code Mode n'est pas toujours le bon choix. Les outils MCP directs restent plus simples pour les actions courtes et évidentes. L'environnement d'exécution supplémentaire devient utile lorsqu'une tâche comporte des appels dépendants, nécessite un traitement local des données ou doit parcourir une API vaste et évolutive. C'est par exemple le cas d'une spécification OpenAPI qui peut dépasser la fenêtre de contexte du modèle.\n\nAu fil de cette série, nous allons :\n\n1. **Au-delà d'un appel d'outil à la fois : découvrir le Code Mode** : construire deux outils `Drive` directs autour d'un fichier Markdown de test et observer comment l'intégralité de son contenu traverse le contexte du modèle avant l'appel d'outil suivant.\n2. **Laisser le modèle orchestrer les outils dans un environnement local** : remplacer les deux outils directs par un outil `code` générique, exposer une façade `Drive` typée et introduire l'interface de l'exécuteur que les parties suivantes remplaceront. L'évaluateur local basé sur le constructeur `Function` est volontairement un raccourci réservé au développement de confiance, et non un bac à sable de production.\n3. **Rechercher dans une spécification OpenAPI sans remplir le contexte** : conserver le document OpenAPI dans le serveur, résoudre ses références `$ref` locales et laisser le code généré effectuer ses recherches dans une façade de types compacte au lieu de renvoyer toute la spécification au modèle.\n4. **Appeler des API avec le Code Mode et ne renvoyer que l'essentiel** : ajouter un outil `execute` distinct avec une fonction `api.request()` contrôlée par l'hôte. Nous validerons les options de la requête, appellerons l'API MarketHub locale utilisée pour les tests et renverrons une projection ciblée plutôt que la réponse complète de l'API.\n5. **Remplacer l'évaluateur par des Workers Cloudflare isolés** : remplacer uniquement l'exécuteur par de nouveaux Workers dynamiques. La recherche s'exécutera sans accès sortant, tandis que les appels passeront par une passerelle avec une liste d'autorisations. Les identifiants resteront hors du code généré. Nous aborderons également les limites des résultats, les limites de ressources et les délais imposés par l'hôte.\n\nLe dépôt associé, \u003CGitHubLink repo=\"barbapapazes\u002Fcode-mode\" \u002F>, est un manuel exécutable pour cette série. Chaque article dispose d'une branche qui représente un état complet, d'une petite évaluation et d'un diff ciblé par rapport à l'étape précédente. Je vous recommande d'extraire une branche et d'étudier l'implémentation pour mieux comprendre les concepts, car les articles ne couvriront pas chaque détail.\n\n::callout{icon=\"i-ph-info-duotone\" color=\"info\"}\nCette série suppose que vous connaissez TypeScript, les promesses JavaScript, les API HTTP et les concepts de base de MCP. Les étapes locales ne contiennent aucun identifiant. Les parties 2 à 4 utilisent un évaluateur local de confiance basé sur le constructeur `Function` pour le développement. La partie 5 fournit une base de déploiement Cloudflare et une évaluation structurelle de la sécurité.\n::\n\n## Chapitres\n\n::series-chapters-list\n---\nclass: mx-auto max-w-5xl\n---\n::\n",{"title":1045,"description":1186},{"loc":1191},"fr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers","Créez un serveur MCP économe en contexte pour les API décrites avec OpenAPI",[1198,1199,1200,1201,1202,1203,1204],"ai","ai-agents","mcp","code-mode","openapi","cloudflare","typescript","HqoFmkgNETmMSWXeXg8BeVY4Vjz1w13UtWu2_6vvVaE",[1207,1209,1216,1223,1230],{"contentId":1027,"title":5,"description":1029,"path":1035,"part":60,"github":1208,"topics":1033},{"branch":1032},{"contentId":1210,"title":1211,"description":1212,"path":1213,"part":78,"github":1214,"topics":1033},"2eaa3055-6247-4237-aad6-cde698eedb82","Laisser le modèle orchestrer les outils avec du code local","Créez un environnement Code Mode local minimal et fiable avec une façade Drive typée, ainsi qu'un exécuteur prêt à être isolé.","\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Flet-the-model-orchestrate-tools-with-a-local-code-runtime",{"branch":1215},"part-2-generic-code-mode",{"contentId":1217,"title":1218,"description":1219,"path":1220,"part":85,"github":1221,"topics":1033},"c32e838b-fc65-4cf8-a541-db7017ff7c0e","Chercher dans OpenAPI sans saturer la fenêtre de contexte","Conservez la spécification OpenAPI côté serveur et recherchez dans une façade typée compacte sans renvoyer le document complet.","\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fsearching-openapi-specification-without-filling-the-context",{"branch":1222},"part-3-search",{"contentId":1224,"title":1225,"description":1226,"path":1227,"part":108,"github":1228,"topics":1033},"5097481f-e94c-409c-865b-78f9bbf83a68","Appeler des API avec le Code Mode et garder l'essentiel","Utilisez une fonction de requête contrôlée par l'hôte pour valider et exécuter un appel API ciblé, puis ne renvoyer que le résultat utile.","\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters",{"branch":1229},"part-4-local-execute",{"contentId":1231,"title":1154,"description":1232,"path":1233,"part":113,"github":1234,"topics":1033},"334230f9-e74b-4174-b2f1-05bf1ec0d1fd","Remplacez l'évaluateur local basé sur Function par des Workers Cloudflare isolés, avec des sorties bornées et un accès réseau contrôlé.","\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Freplacing-local-eval-with-isolated-cloudflare-workers",{"branch":1235},"part-5-dynamic-workers",1795016702031]