[{"data":1,"prerenderedAt":1904},["ShallowReactive",2],{"series-\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters":3,"series-context-\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers":1705},{"id":4,"title":5,"body":6,"contentId":1690,"date":1691,"description":1692,"extension":1693,"github":1694,"meetTheInstructor":1696,"meta":1697,"navigation":772,"part":186,"path":1698,"rawbody":1699,"robots":1696,"schemaOrg":1696,"seo":1700,"seriesSlug":1701,"sitemap":1702,"stem":1703,"subtitle":1696,"topics":1696,"__hash__":1704},"series\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters.md","Appeler des API avec le Code Mode et garder l'essentiel",{"type":7,"value":8,"toc":1683},"minimark",[9,13,16,21,24,155,268,271,274,278,285,288,601,604,607,625,628,637,640,963,973,976,1114,1131,1135,1142,1182,1185,1484,1487,1491,1494,1497,1553,1556,1559,1569,1572,1575,1578,1662,1665,1669,1672,1679],[10,11,12],"p",{},"Nous avons vu comment laisser le modèle écrire du code JavaScript pour rechercher dans une spécification OpenAPI plus volumineuse que la fenêtre de contexte. La spécification peut continuer à grandir, même si l'environnement d'exécution conserve des limites concrètes sur le temps d'exécution, la mémoire et les données renvoyées.",[10,14,15],{},"Voyons maintenant comment laisser le modèle écrire du JavaScript pour interagir avec notre API à partir des connaissances recueillies dans la spécification OpenAPI.",[17,18,20],"h2",{"id":19},"notre-mcp-a-besoin-dun-deuxième-outil","Notre MCP a besoin d'un deuxième outil",[10,22,23],{},"Notre objectif était de créer un système qui facilite les interactions entre le LLM et notre API. Pour le moment, notre LLM peut explorer et comprendre l'API :",[25,26,32],"pre",{"className":27,"code":28,"filename":29,"language":30,"meta":31,"style":31},"language-json shiki shiki-themes github-light github-light github-dark","{\n  \"code\": \"async () => {\\n  const results = [];\\n  for (const [path, methods] of Object.entries(spec.paths)) {\\n    for (const [method, operation] of Object.entries(methods)) {\\n      if (operation?.tags?.some(tag => tag.toLowerCase() === 'returns')) {\\n        results.push({\\n          method: method.toUpperCase(),\\n          path,\\n          operationId: operation.operationId,\\n          summary: operation.summary,\\n          description: operation.description,\\n          parameters: operation.parameters,\\n          requestBody: operation.requestBody,\\n        });\\n      }\\n    }\\n  }\\n  return results;\\n}\"\n}\n","LLM Tool Call","json","",[33,34,35,44,149],"code",{"__ignoreMap":31},[36,37,40],"span",{"class":38,"line":39},"line",1,[36,41,43],{"class":42},"sxrX7","{\n",[36,45,47,51,54,58,61,64,66,69,71,74,76,79,81,84,86,89,91,94,96,99,101,104,106,109,111,114,116,119,121,124,126,129,131,134,136,139,141,144,146],{"class":38,"line":46},2,[36,48,50],{"class":49},"sBjJW","  \"code\"",[36,52,53],{"class":42},": ",[36,55,57],{"class":56},"sIIMD","\"async () => {",[36,59,60],{"class":49},"\\n",[36,62,63],{"class":56},"  const results = [];",[36,65,60],{"class":49},[36,67,68],{"class":56},"  for (const [path, methods] of Object.entries(spec.paths)) {",[36,70,60],{"class":49},[36,72,73],{"class":56},"    for (const [method, operation] of Object.entries(methods)) {",[36,75,60],{"class":49},[36,77,78],{"class":56},"      if (operation?.tags?.some(tag => tag.toLowerCase() === 'returns')) {",[36,80,60],{"class":49},[36,82,83],{"class":56},"        results.push({",[36,85,60],{"class":49},[36,87,88],{"class":56},"          method: method.toUpperCase(),",[36,90,60],{"class":49},[36,92,93],{"class":56},"          path,",[36,95,60],{"class":49},[36,97,98],{"class":56},"          operationId: operation.operationId,",[36,100,60],{"class":49},[36,102,103],{"class":56},"          summary: operation.summary,",[36,105,60],{"class":49},[36,107,108],{"class":56},"          description: operation.description,",[36,110,60],{"class":49},[36,112,113],{"class":56},"          parameters: operation.parameters,",[36,115,60],{"class":49},[36,117,118],{"class":56},"          requestBody: operation.requestBody,",[36,120,60],{"class":49},[36,122,123],{"class":56},"        });",[36,125,60],{"class":49},[36,127,128],{"class":56},"      }",[36,130,60],{"class":49},[36,132,133],{"class":56},"    }",[36,135,60],{"class":49},[36,137,138],{"class":56},"  }",[36,140,60],{"class":49},[36,142,143],{"class":56},"  return results;",[36,145,60],{"class":49},[36,147,148],{"class":56},"}\"\n",[36,150,152],{"class":38,"line":151},3,[36,153,154],{"class":42},"}\n",[25,156,159],{"className":27,"code":157,"filename":158,"language":30,"meta":31,"style":31},"[\n  {\n    \"method\": \"GET\",\n    \"path\": \"\u002Freturns\",\n    \"operationId\": \"listReturns\",\n    \"summary\": \"List return requests\",\n    \"description\": \"List return requests, optionally narrowed to an order, order item, seller, or return status.\",\n    \"parameters\": [],\n    \"requestBody\": null\n  }\n]\n","LLM Tool Output",[33,160,161,166,171,184,197,210,223,236,245,256,262],{"__ignoreMap":31},[36,162,163],{"class":38,"line":39},[36,164,165],{"class":42},"[\n",[36,167,168],{"class":38,"line":46},[36,169,170],{"class":42},"  {\n",[36,172,173,176,178,181],{"class":38,"line":151},[36,174,175],{"class":49},"    \"method\"",[36,177,53],{"class":42},[36,179,180],{"class":56},"\"GET\"",[36,182,183],{"class":42},",\n",[36,185,187,190,192,195],{"class":38,"line":186},4,[36,188,189],{"class":49},"    \"path\"",[36,191,53],{"class":42},[36,193,194],{"class":56},"\"\u002Freturns\"",[36,196,183],{"class":42},[36,198,200,203,205,208],{"class":38,"line":199},5,[36,201,202],{"class":49},"    \"operationId\"",[36,204,53],{"class":42},[36,206,207],{"class":56},"\"listReturns\"",[36,209,183],{"class":42},[36,211,213,216,218,221],{"class":38,"line":212},6,[36,214,215],{"class":49},"    \"summary\"",[36,217,53],{"class":42},[36,219,220],{"class":56},"\"List return requests\"",[36,222,183],{"class":42},[36,224,226,229,231,234],{"class":38,"line":225},7,[36,227,228],{"class":49},"    \"description\"",[36,230,53],{"class":42},[36,232,233],{"class":56},"\"List return requests, optionally narrowed to an order, order item, seller, or return status.\"",[36,235,183],{"class":42},[36,237,239,242],{"class":38,"line":238},8,[36,240,241],{"class":49},"    \"parameters\"",[36,243,244],{"class":42},": [],\n",[36,246,248,251,253],{"class":38,"line":247},9,[36,249,250],{"class":49},"    \"requestBody\"",[36,252,53],{"class":42},[36,254,255],{"class":49},"null\n",[36,257,259],{"class":38,"line":258},10,[36,260,261],{"class":42},"  }\n",[36,263,265],{"class":38,"line":264},11,[36,266,267],{"class":42},"]\n",[10,269,270],{},"Il ne peut toutefois pas encore interagir avec elle.",[10,272,273],{},"Nous devons pour cela lui fournir un deuxième outil : l'exécuteur.",[17,275,277],{"id":276},"loutil-dexécution","L'outil d'exécution",[10,279,280,281,284],{},"L'outil d'exécution complète l'outil de recherche. Sous le capot, il enveloppe un client API préconfiguré, ici une fonction ",[33,282,283],{},"fetch",", qui permet au modèle d'appeler l'API grâce aux informations recueillies dans la spécification OpenAPI.",[10,286,287],{},"Dans les grandes lignes, il ressemble beaucoup à l'outil de recherche. Nous fournissons au modèle un environnement préconfiguré dans lequel écrire du code pour une API typée et prédéfinie. Le modèle orchestre une ou plusieurs requêtes selon la complexité de la tâche, puis ne renvoie que les données utiles.",[25,289,294],{"className":290,"code":291,"filename":292,"language":293,"meta":31,"style":31},"language-typescript shiki shiki-themes github-light github-light github-dark","export function registerExecuteTool(server: McpServer): void {\n  server.registerTool(\n    'execute',\n    {\n      title: 'MarketHub API Code Executor',\n      description: '...',\n      inputSchema: z.object({\n        code: z\n          .string()\n          .max(MAX_CODE_LENGTH)\n          .describe('An async arrow function that executes a MarketHub API request')\n      }),\n    },\n    async ({ code }) => {\n      try {\n        const result = await evaluateExecuteCode(code)\n        return { content: [{ type: 'text', text: formatExecuteResult(result) }] }\n      }\n      catch (error) {\n        return {\n          content: [{ type: 'text', text: `Execute failed: ${errorMessage(error)}` }],\n          isError: true\n        }\n      }\n    }\n  )\n}\n","executor.ts","typescript",[33,295,296,333,344,351,356,366,376,387,392,403,418,432,438,444,463,471,492,513,519,528,535,564,573,579,584,590,596],{"__ignoreMap":31},[36,297,298,302,305,309,312,316,319,322,325,327,330],{"class":38,"line":39},[36,299,301],{"class":300},"s8jYJ","export",[36,303,304],{"class":300}," function",[36,306,308],{"class":307},"snPdu"," registerExecuteTool",[36,310,311],{"class":42},"(",[36,313,315],{"class":314},"sP4rz","server",[36,317,318],{"class":300},":",[36,320,321],{"class":307}," McpServer",[36,323,324],{"class":42},")",[36,326,318],{"class":300},[36,328,329],{"class":49}," void",[36,331,332],{"class":42}," {\n",[36,334,335,338,341],{"class":38,"line":46},[36,336,337],{"class":42},"  server.",[36,339,340],{"class":307},"registerTool",[36,342,343],{"class":42},"(\n",[36,345,346,349],{"class":38,"line":151},[36,347,348],{"class":56},"    'execute'",[36,350,183],{"class":42},[36,352,353],{"class":38,"line":186},[36,354,355],{"class":42},"    {\n",[36,357,358,361,364],{"class":38,"line":199},[36,359,360],{"class":42},"      title: ",[36,362,363],{"class":56},"'MarketHub API Code Executor'",[36,365,183],{"class":42},[36,367,368,371,374],{"class":38,"line":212},[36,369,370],{"class":42},"      description: ",[36,372,373],{"class":56},"'...'",[36,375,183],{"class":42},[36,377,378,381,384],{"class":38,"line":225},[36,379,380],{"class":42},"      inputSchema: z.",[36,382,383],{"class":307},"object",[36,385,386],{"class":42},"({\n",[36,388,389],{"class":38,"line":238},[36,390,391],{"class":42},"        code: z\n",[36,393,394,397,400],{"class":38,"line":247},[36,395,396],{"class":42},"          .",[36,398,399],{"class":307},"string",[36,401,402],{"class":42},"()\n",[36,404,405,407,410,412,415],{"class":38,"line":258},[36,406,396],{"class":42},[36,408,409],{"class":307},"max",[36,411,311],{"class":42},[36,413,414],{"class":49},"MAX_CODE_LENGTH",[36,416,417],{"class":42},")\n",[36,419,420,422,425,427,430],{"class":38,"line":264},[36,421,396],{"class":42},[36,423,424],{"class":307},"describe",[36,426,311],{"class":42},[36,428,429],{"class":56},"'An async arrow function that executes a MarketHub API request'",[36,431,417],{"class":42},[36,433,435],{"class":38,"line":434},12,[36,436,437],{"class":42},"      }),\n",[36,439,441],{"class":38,"line":440},13,[36,442,443],{"class":42},"    },\n",[36,445,447,450,453,455,458,461],{"class":38,"line":446},14,[36,448,449],{"class":300},"    async",[36,451,452],{"class":42}," ({ ",[36,454,33],{"class":314},[36,456,457],{"class":42}," }) ",[36,459,460],{"class":300},"=>",[36,462,332],{"class":42},[36,464,466,469],{"class":38,"line":465},15,[36,467,468],{"class":300},"      try",[36,470,332],{"class":42},[36,472,474,477,480,483,486,489],{"class":38,"line":473},16,[36,475,476],{"class":300},"        const",[36,478,479],{"class":49}," result",[36,481,482],{"class":300}," =",[36,484,485],{"class":300}," await",[36,487,488],{"class":307}," evaluateExecuteCode",[36,490,491],{"class":42},"(code)\n",[36,493,495,498,501,504,507,510],{"class":38,"line":494},17,[36,496,497],{"class":300},"        return",[36,499,500],{"class":42}," { content: [{ type: ",[36,502,503],{"class":56},"'text'",[36,505,506],{"class":42},", text: ",[36,508,509],{"class":307},"formatExecuteResult",[36,511,512],{"class":42},"(result) }] }\n",[36,514,516],{"class":38,"line":515},18,[36,517,518],{"class":42},"      }\n",[36,520,522,525],{"class":38,"line":521},19,[36,523,524],{"class":300},"      catch",[36,526,527],{"class":42}," (error) {\n",[36,529,531,533],{"class":38,"line":530},20,[36,532,497],{"class":300},[36,534,332],{"class":42},[36,536,538,541,543,545,548,551,553,556,558,561],{"class":38,"line":537},21,[36,539,540],{"class":42},"          content: [{ type: ",[36,542,503],{"class":56},[36,544,506],{"class":42},[36,546,547],{"class":56},"`Execute failed: ${",[36,549,550],{"class":307},"errorMessage",[36,552,311],{"class":56},[36,554,555],{"class":42},"error",[36,557,324],{"class":56},[36,559,560],{"class":56},"}`",[36,562,563],{"class":42}," }],\n",[36,565,567,570],{"class":38,"line":566},22,[36,568,569],{"class":42},"          isError: ",[36,571,572],{"class":49},"true\n",[36,574,576],{"class":38,"line":575},23,[36,577,578],{"class":42},"        }\n",[36,580,582],{"class":38,"line":581},24,[36,583,518],{"class":42},[36,585,587],{"class":38,"line":586},25,[36,588,589],{"class":42},"    }\n",[36,591,593],{"class":38,"line":592},26,[36,594,595],{"class":42},"  )\n",[36,597,599],{"class":38,"line":598},27,[36,600,154],{"class":42},[10,602,603],{},"La ressemblance avec l'outil de recherche saute aux yeux. Nous recevons une fonction fléchée JavaScript, nous l'évaluons et nous renvoyons son résultat.",[10,605,606],{},"Deux différences comptent :",[608,609,610,614],"ol",{},[611,612,613],"li",{},"La description indique au modèle qu'il peut écrire du code pour l'API et qu'il doit ne renvoyer que les données utiles.",[611,615,616,617,620,621,624],{},"Nous utilisons ",[33,618,619],{},"evaluateExecuteCode"," au lieu de ",[33,622,623],{},"evaluateSearchCode",". Les deux fonctions évaluent du code, mais les données disponibles dans leur contexte diffèrent.",[10,626,627],{},"La description commence par expliquer brièvement le rôle de l'outil.",[25,629,635],{"className":630,"code":632,"filename":633,"language":634,"meta":31},[631],"language-text","Execute JavaScript code against the local MarketHub API.\n\nFirst use the 'search' tool to find the right endpoint, method, parameters, and request body, then write code using api.request().\n","Exemple","text",[33,636,632],{"__ignoreMap":31},[10,638,639],{},"Elle fournit ensuite une interface TypeScript qui indique précisément au modèle comment écrire son code.",[25,641,643],{"className":290,"code":642,"filename":633,"language":293,"meta":31,"style":31},"interface ApiRequestOptions {\n  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'\n  path: string\n  query?: Record\u003Cstring, string | number | boolean | undefined>\n  body?: unknown\n  contentType?: string\n  rawBody?: boolean\n}\n\ninterface ApiResponse\u003CT = unknown> {\n  success: boolean\n  status: number\n  result: T\n  errors: Array\u003C{ code: string | number, message: string }>\n  messages: Array\u003C{ code: string | number, message: string }>\n}\n\ndeclare const api: {\n  request: \u003CT = unknown>(options: ApiRequestOptions) => Promise\u003CApiResponse\u003CT>>\n}\n",[33,644,645,655,686,696,735,745,754,764,768,774,794,803,813,823,859,890,894,898,913,959],{"__ignoreMap":31},[36,646,647,650,653],{"class":38,"line":39},[36,648,649],{"class":300},"interface",[36,651,652],{"class":307}," ApiRequestOptions",[36,654,332],{"class":42},[36,656,657,660,662,665,668,671,673,676,678,681,683],{"class":38,"line":46},[36,658,659],{"class":314},"  method",[36,661,318],{"class":300},[36,663,664],{"class":56}," 'GET'",[36,666,667],{"class":300}," |",[36,669,670],{"class":56}," 'POST'",[36,672,667],{"class":300},[36,674,675],{"class":56}," 'PUT'",[36,677,667],{"class":300},[36,679,680],{"class":56}," 'PATCH'",[36,682,667],{"class":300},[36,684,685],{"class":56}," 'DELETE'\n",[36,687,688,691,693],{"class":38,"line":151},[36,689,690],{"class":314},"  path",[36,692,318],{"class":300},[36,694,695],{"class":49}," string\n",[36,697,698,701,704,707,710,712,715,717,719,722,724,727,729,732],{"class":38,"line":186},[36,699,700],{"class":314},"  query",[36,702,703],{"class":300},"?:",[36,705,706],{"class":307}," Record",[36,708,709],{"class":42},"\u003C",[36,711,399],{"class":49},[36,713,714],{"class":42},", ",[36,716,399],{"class":49},[36,718,667],{"class":300},[36,720,721],{"class":49}," number",[36,723,667],{"class":300},[36,725,726],{"class":49}," boolean",[36,728,667],{"class":300},[36,730,731],{"class":49}," undefined",[36,733,734],{"class":42},">\n",[36,736,737,740,742],{"class":38,"line":199},[36,738,739],{"class":314},"  body",[36,741,703],{"class":300},[36,743,744],{"class":49}," unknown\n",[36,746,747,750,752],{"class":38,"line":212},[36,748,749],{"class":314},"  contentType",[36,751,703],{"class":300},[36,753,695],{"class":49},[36,755,756,759,761],{"class":38,"line":225},[36,757,758],{"class":314},"  rawBody",[36,760,703],{"class":300},[36,762,763],{"class":49}," boolean\n",[36,765,766],{"class":38,"line":238},[36,767,154],{"class":42},[36,769,770],{"class":38,"line":247},[36,771,773],{"emptyLinePlaceholder":772},true,"\n",[36,775,776,778,781,783,786,788,791],{"class":38,"line":258},[36,777,649],{"class":300},[36,779,780],{"class":307}," ApiResponse",[36,782,709],{"class":42},[36,784,785],{"class":307},"T",[36,787,482],{"class":300},[36,789,790],{"class":49}," unknown",[36,792,793],{"class":42},"> {\n",[36,795,796,799,801],{"class":38,"line":264},[36,797,798],{"class":314},"  success",[36,800,318],{"class":300},[36,802,763],{"class":49},[36,804,805,808,810],{"class":38,"line":434},[36,806,807],{"class":314},"  status",[36,809,318],{"class":300},[36,811,812],{"class":49}," number\n",[36,814,815,818,820],{"class":38,"line":440},[36,816,817],{"class":314},"  result",[36,819,318],{"class":300},[36,821,822],{"class":307}," T\n",[36,824,825,828,830,833,836,838,840,843,845,847,849,852,854,856],{"class":38,"line":446},[36,826,827],{"class":314},"  errors",[36,829,318],{"class":300},[36,831,832],{"class":307}," Array",[36,834,835],{"class":42},"\u003C{ ",[36,837,33],{"class":314},[36,839,318],{"class":300},[36,841,842],{"class":49}," string",[36,844,667],{"class":300},[36,846,721],{"class":49},[36,848,714],{"class":42},[36,850,851],{"class":314},"message",[36,853,318],{"class":300},[36,855,842],{"class":49},[36,857,858],{"class":42}," }>\n",[36,860,861,864,866,868,870,872,874,876,878,880,882,884,886,888],{"class":38,"line":465},[36,862,863],{"class":314},"  messages",[36,865,318],{"class":300},[36,867,832],{"class":307},[36,869,835],{"class":42},[36,871,33],{"class":314},[36,873,318],{"class":300},[36,875,842],{"class":49},[36,877,667],{"class":300},[36,879,721],{"class":49},[36,881,714],{"class":42},[36,883,851],{"class":314},[36,885,318],{"class":300},[36,887,842],{"class":49},[36,889,858],{"class":42},[36,891,892],{"class":38,"line":473},[36,893,154],{"class":42},[36,895,896],{"class":38,"line":494},[36,897,773],{"emptyLinePlaceholder":772},[36,899,900,903,906,909,911],{"class":38,"line":515},[36,901,902],{"class":300},"declare",[36,904,905],{"class":300}," const",[36,907,908],{"class":49}," api",[36,910,318],{"class":300},[36,912,332],{"class":42},[36,914,915,918,920,923,925,927,929,932,935,937,939,942,944,947,949,952,954,956],{"class":38,"line":521},[36,916,917],{"class":307},"  request",[36,919,318],{"class":300},[36,921,922],{"class":42}," \u003C",[36,924,785],{"class":307},[36,926,482],{"class":300},[36,928,790],{"class":49},[36,930,931],{"class":42},">(",[36,933,934],{"class":314},"options",[36,936,318],{"class":300},[36,938,652],{"class":307},[36,940,941],{"class":42},") ",[36,943,460],{"class":300},[36,945,946],{"class":307}," Promise",[36,948,709],{"class":42},[36,950,951],{"class":307},"ApiResponse",[36,953,709],{"class":42},[36,955,785],{"class":307},[36,957,958],{"class":42},">>\n",[36,960,961],{"class":38,"line":530},[36,962,154],{"class":42},[10,964,965,966,969,970,972],{},"Nous pouvons maintenant écrire du code pour l'API. L'interface ",[33,967,968],{},"ApiRequestOptions"," montre clairement que nous ne faisons rien de plus qu'envelopper ",[33,971,283],{},". Les paramètres sont presque identiques, mais simplifiés pour ne présenter au modèle que les informations nécessaires. Pour la réponse, nous préparons les données afin de réduire le travail du modèle.",[10,974,975],{},"Enfin, la description contient un petit exemple d'utilisation de l'outil.",[25,977,979],{"className":290,"code":978,"filename":633,"language":293,"meta":31,"style":31},"async () => {\n  const response = await api.request({\n    method: 'GET',\n    path: '\u002Fproducts',\n    query: { 'status:eq': 'active', '_per_page': 5 }\n  })\n\n  return response.result.map(product => ({\n    id: product.id,\n    name: product.name,\n    status: product.status\n  }))\n}\n",[33,980,981,993,1013,1023,1033,1059,1064,1068,1090,1095,1100,1105,1110],{"__ignoreMap":31},[36,982,983,986,989,991],{"class":38,"line":39},[36,984,985],{"class":300},"async",[36,987,988],{"class":42}," () ",[36,990,460],{"class":300},[36,992,332],{"class":42},[36,994,995,998,1001,1003,1005,1008,1011],{"class":38,"line":46},[36,996,997],{"class":300},"  const",[36,999,1000],{"class":49}," response",[36,1002,482],{"class":300},[36,1004,485],{"class":300},[36,1006,1007],{"class":42}," api.",[36,1009,1010],{"class":307},"request",[36,1012,386],{"class":42},[36,1014,1015,1018,1021],{"class":38,"line":151},[36,1016,1017],{"class":42},"    method: ",[36,1019,1020],{"class":56},"'GET'",[36,1022,183],{"class":42},[36,1024,1025,1028,1031],{"class":38,"line":186},[36,1026,1027],{"class":42},"    path: ",[36,1029,1030],{"class":56},"'\u002Fproducts'",[36,1032,183],{"class":42},[36,1034,1035,1038,1041,1043,1046,1048,1051,1053,1056],{"class":38,"line":199},[36,1036,1037],{"class":42},"    query: { ",[36,1039,1040],{"class":56},"'status:eq'",[36,1042,53],{"class":42},[36,1044,1045],{"class":56},"'active'",[36,1047,714],{"class":42},[36,1049,1050],{"class":56},"'_per_page'",[36,1052,53],{"class":42},[36,1054,1055],{"class":49},"5",[36,1057,1058],{"class":42}," }\n",[36,1060,1061],{"class":38,"line":212},[36,1062,1063],{"class":42},"  })\n",[36,1065,1066],{"class":38,"line":225},[36,1067,773],{"emptyLinePlaceholder":772},[36,1069,1070,1073,1076,1079,1081,1084,1087],{"class":38,"line":238},[36,1071,1072],{"class":300},"  return",[36,1074,1075],{"class":42}," response.result.",[36,1077,1078],{"class":307},"map",[36,1080,311],{"class":42},[36,1082,1083],{"class":314},"product",[36,1085,1086],{"class":300}," =>",[36,1088,1089],{"class":42}," ({\n",[36,1091,1092],{"class":38,"line":247},[36,1093,1094],{"class":42},"    id: product.id,\n",[36,1096,1097],{"class":38,"line":258},[36,1098,1099],{"class":42},"    name: product.name,\n",[36,1101,1102],{"class":38,"line":264},[36,1103,1104],{"class":42},"    status: product.status\n",[36,1106,1107],{"class":38,"line":434},[36,1108,1109],{"class":42},"  }))\n",[36,1111,1112],{"class":38,"line":440},[36,1113,154],{"class":42},[1115,1116,1117,1118,1117,1127],"figure",{},"\n  ",[1119,1120,1121,1122,1117],"video",{"autoPlay":772,"loop":772,"muted":772,"playsInline":772},"\n    ",[1123,1124],"source",{"src":1125,"type":1126},"https:\u002F\u002Fimages.soubiran.dev\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters\u002Fexecute-api-request.mp4","video\u002Fmp4",[1128,1129,1130],"figcaption",{},"Exécution d'une requête API qui ne renvoie que les champs sélectionnés pour les produits.",[17,1132,1134],{"id":1133},"code-mode-ou-simple-appel-doutil","Code Mode ou simple appel d'outil",[10,1136,1137,1138,1141],{},"Vous vous demandez peut-être pourquoi ne pas simplement fournir au modèle un appel d'outil classique, comme nous le faisons pour la plupart des MCP. Nous pourrions par exemple imaginer un outil nommé ",[33,1139,1140],{},"list_returns"," qui recevrait l'identifiant d'un vendeur et renverrait la liste des retours. Le modèle n'aurait qu'à l'appeler avec les bons paramètres pour obtenir le résultat.",[10,1143,1144,1145,1148,1149,1152,1153,714,1156,714,1159,714,1162,714,1165,714,1168,714,1171,714,1174,1177,1178,1181],{},"Vous avez raison. Nous aurions pu procéder ainsi. Mais une API de 150 endpoints nécessiterait 150 outils. Nous pourrions réduire ce nombre en regroupant certains endpoints derrière un paramètre, comme le fait le MCP de GitHub. Son outil ",[33,1146,1147],{},"pull_request_read"," possède par exemple un paramètre ",[33,1150,1151],{},"method"," qui accepte les valeurs ",[33,1154,1155],{},"get",[33,1157,1158],{},"get_diff",[33,1160,1161],{},"get_status",[33,1163,1164],{},"get_files",[33,1166,1167],{},"get_commits",[33,1169,1170],{},"get_review_comments",[33,1172,1173],{},"get_reviews",[33,1175,1176],{},"get_comments"," et ",[33,1179,1180],{},"get_check_runs",". Je vous laisse imaginer la complexité sous-jacente et le casse-tête du regroupement. Si GitHub ajoute une méthode demain, son MCP doit être mis à jour.",[10,1183,1184],{},"Le Code Mode permet aussi au modèle d'adapter l'entrée et la sortie de la requête. S'il sait qu'un endpoint renvoie une réponse très détaillée, il peut ne conserver que les champs nécessaires. Il peut également enchaîner les requêtes, créer des boucles, utiliser des conditions, réessayer lorsque le résultat ne correspond pas à ses attentes, etc. Le modèle orchestre librement la requête selon ses besoins.",[25,1186,1188],{"className":290,"code":1187,"filename":633,"language":293,"meta":31,"style":31},"async () => {\n  const sellers = (await api.request({\n    method: 'GET',\n    path: '\u002Fsellers',\n    query: { 'status:eq': 'active', '_per_page': 5 }\n  })).result\n\n  const results = []\n\n  for (const seller of sellers) {\n    const products = (await api.request({\n      method: 'GET',\n      path: '\u002Fproducts',\n      query: {\n        sellerId: seller.id,\n        _embed: 'variants',\n        _per_page: 10\n      }\n    })).result\n\n    for (const product of products) {\n      for (const variant of product.variants ?? []) {\n        results.push({\n          seller: seller.name,\n          product: product.name,\n          sku: variant.sku\n        })\n      }\n    }\n  }\n\n  return results\n}\n",[33,1189,1190,1200,1221,1229,1238,1258,1263,1267,1279,1283,1302,1322,1331,1340,1345,1350,1360,1368,1372,1377,1381,1398,1421,1431,1436,1441,1446,1451,1456,1461,1466,1471,1479],{"__ignoreMap":31},[36,1191,1192,1194,1196,1198],{"class":38,"line":39},[36,1193,985],{"class":300},[36,1195,988],{"class":42},[36,1197,460],{"class":300},[36,1199,332],{"class":42},[36,1201,1202,1204,1207,1209,1212,1215,1217,1219],{"class":38,"line":46},[36,1203,997],{"class":300},[36,1205,1206],{"class":49}," sellers",[36,1208,482],{"class":300},[36,1210,1211],{"class":42}," (",[36,1213,1214],{"class":300},"await",[36,1216,1007],{"class":42},[36,1218,1010],{"class":307},[36,1220,386],{"class":42},[36,1222,1223,1225,1227],{"class":38,"line":151},[36,1224,1017],{"class":42},[36,1226,1020],{"class":56},[36,1228,183],{"class":42},[36,1230,1231,1233,1236],{"class":38,"line":186},[36,1232,1027],{"class":42},[36,1234,1235],{"class":56},"'\u002Fsellers'",[36,1237,183],{"class":42},[36,1239,1240,1242,1244,1246,1248,1250,1252,1254,1256],{"class":38,"line":199},[36,1241,1037],{"class":42},[36,1243,1040],{"class":56},[36,1245,53],{"class":42},[36,1247,1045],{"class":56},[36,1249,714],{"class":42},[36,1251,1050],{"class":56},[36,1253,53],{"class":42},[36,1255,1055],{"class":49},[36,1257,1058],{"class":42},[36,1259,1260],{"class":38,"line":212},[36,1261,1262],{"class":42},"  })).result\n",[36,1264,1265],{"class":38,"line":225},[36,1266,773],{"emptyLinePlaceholder":772},[36,1268,1269,1271,1274,1276],{"class":38,"line":238},[36,1270,997],{"class":300},[36,1272,1273],{"class":49}," results",[36,1275,482],{"class":300},[36,1277,1278],{"class":42}," []\n",[36,1280,1281],{"class":38,"line":247},[36,1282,773],{"emptyLinePlaceholder":772},[36,1284,1285,1288,1290,1293,1296,1299],{"class":38,"line":258},[36,1286,1287],{"class":300},"  for",[36,1289,1211],{"class":42},[36,1291,1292],{"class":300},"const",[36,1294,1295],{"class":49}," seller",[36,1297,1298],{"class":300}," of",[36,1300,1301],{"class":42}," sellers) {\n",[36,1303,1304,1307,1310,1312,1314,1316,1318,1320],{"class":38,"line":264},[36,1305,1306],{"class":300},"    const",[36,1308,1309],{"class":49}," products",[36,1311,482],{"class":300},[36,1313,1211],{"class":42},[36,1315,1214],{"class":300},[36,1317,1007],{"class":42},[36,1319,1010],{"class":307},[36,1321,386],{"class":42},[36,1323,1324,1327,1329],{"class":38,"line":434},[36,1325,1326],{"class":42},"      method: ",[36,1328,1020],{"class":56},[36,1330,183],{"class":42},[36,1332,1333,1336,1338],{"class":38,"line":440},[36,1334,1335],{"class":42},"      path: ",[36,1337,1030],{"class":56},[36,1339,183],{"class":42},[36,1341,1342],{"class":38,"line":446},[36,1343,1344],{"class":42},"      query: {\n",[36,1346,1347],{"class":38,"line":465},[36,1348,1349],{"class":42},"        sellerId: seller.id,\n",[36,1351,1352,1355,1358],{"class":38,"line":473},[36,1353,1354],{"class":42},"        _embed: ",[36,1356,1357],{"class":56},"'variants'",[36,1359,183],{"class":42},[36,1361,1362,1365],{"class":38,"line":494},[36,1363,1364],{"class":42},"        _per_page: ",[36,1366,1367],{"class":49},"10\n",[36,1369,1370],{"class":38,"line":515},[36,1371,518],{"class":42},[36,1373,1374],{"class":38,"line":521},[36,1375,1376],{"class":42},"    })).result\n",[36,1378,1379],{"class":38,"line":530},[36,1380,773],{"emptyLinePlaceholder":772},[36,1382,1383,1386,1388,1390,1393,1395],{"class":38,"line":537},[36,1384,1385],{"class":300},"    for",[36,1387,1211],{"class":42},[36,1389,1292],{"class":300},[36,1391,1392],{"class":49}," product",[36,1394,1298],{"class":300},[36,1396,1397],{"class":42}," products) {\n",[36,1399,1400,1403,1405,1407,1410,1412,1415,1418],{"class":38,"line":566},[36,1401,1402],{"class":300},"      for",[36,1404,1211],{"class":42},[36,1406,1292],{"class":300},[36,1408,1409],{"class":49}," variant",[36,1411,1298],{"class":300},[36,1413,1414],{"class":42}," product.variants ",[36,1416,1417],{"class":300},"??",[36,1419,1420],{"class":42}," []) {\n",[36,1422,1423,1426,1429],{"class":38,"line":575},[36,1424,1425],{"class":42},"        results.",[36,1427,1428],{"class":307},"push",[36,1430,386],{"class":42},[36,1432,1433],{"class":38,"line":581},[36,1434,1435],{"class":42},"          seller: seller.name,\n",[36,1437,1438],{"class":38,"line":586},[36,1439,1440],{"class":42},"          product: product.name,\n",[36,1442,1443],{"class":38,"line":592},[36,1444,1445],{"class":42},"          sku: variant.sku\n",[36,1447,1448],{"class":38,"line":598},[36,1449,1450],{"class":42},"        })\n",[36,1452,1454],{"class":38,"line":1453},28,[36,1455,518],{"class":42},[36,1457,1459],{"class":38,"line":1458},29,[36,1460,589],{"class":42},[36,1462,1464],{"class":38,"line":1463},30,[36,1465,261],{"class":42},[36,1467,1469],{"class":38,"line":1468},31,[36,1470,773],{"emptyLinePlaceholder":772},[36,1472,1474,1476],{"class":38,"line":1473},32,[36,1475,1072],{"class":300},[36,1477,1478],{"class":42}," results\n",[36,1480,1482],{"class":38,"line":1481},33,[36,1483,154],{"class":42},[10,1485,1486],{},"Avec des appels d'outils directs, ce processus nécessite plusieurs allers-retours avec l'Agent. Le modèle reçoit chaque résultat, décide de la suite et envoie un nouvel appel. Le Code Mode conserve le contrôle du flux, le filtrage et la préparation du résultat dans le programme généré.",[17,1488,1490],{"id":1489},"ne-renvoyer-que-les-données-utiles","Ne renvoyer que les données utiles",[10,1492,1493],{},"Avec un peu de recul, cette approche peut sembler inutilement complexe. Comparons les deux options avant d'étudier les mesures en jetons.",[10,1495,1496],{},"L'instantané OpenAPI de Cloudflare utilisé dans cette série contient 23 792 523 caractères. Une division par quatre donne une estimation d'environ 6 millions de jetons, même si le nombre exact varie selon le modèle et le contenu.",[1498,1499,1500,1516],"table",{},[1501,1502,1503],"thead",{},[1504,1505,1506,1510,1513],"tr",{},[1507,1508,1509],"th",{},"Point étudié",[1507,1511,1512],{},"Appels d'outils directs",[1507,1514,1515],{},"Code Mode",[1517,1518,1519,1531,1542],"tbody",{},[1504,1520,1521,1525,1528],{},[1522,1523,1524],"td",{},"Tâches dépendantes",[1522,1526,1527],{},"Le modèle reçoit chaque résultat intermédiaire avant de choisir l'appel suivant.",[1522,1529,1530],{},"Le programme généré transmet les valeurs intermédiaires entre les appels et ne renvoie que sa projection finale.",[1504,1532,1533,1536,1539],{},[1522,1534,1535],{},"API volumineuse",[1522,1537,1538],{},"Le serveur doit exposer et documenter un ensemble d'outils parmi lesquels le modèle choisit.",[1522,1540,1541],{},"Le modèle peut rechercher dans une spécification conservée côté serveur, puis composer les appels ciblés dont il a besoin.",[1504,1543,1544,1547,1550],{},[1522,1545,1546],{},"Préparation des données",[1522,1548,1549],{},"Le modèle reçoit souvent la réponse de chaque outil avant de pouvoir la réduire.",[1522,1551,1552],{},"Le programme généré peut filtrer, agréger et projeter les données avant de les renvoyer.",[10,1554,1555],{},"Un serveur d'outils directs bien conçu peut lui aussi traiter les données par lots et garder des réponses compactes. Le Code Mode devient surtout utile lorsqu'une tâche nécessite des appels dépendants, un traitement local ou une API qui évolue.",[10,1557,1558],{},"Pour l'illustrer, demandons à notre Agent de lister les 10 Workers qui consomment le plus de CPU :",[1115,1560,1117,1561,1117,1566],{},[1119,1562,1121,1563,1117],{"autoPlay":772,"loop":772,"muted":772,"playsInline":772},[1123,1564],{"src":1565,"type":1126},"https:\u002F\u002Fimages.soubiran.dev\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters\u002Flist-top-cpu-intensive-workers.mp4",[1128,1567,1568],{},"Liste des 10 Workers qui consomment le plus de CPU avec le Code Mode.",[10,1570,1571],{},"Lors de cet enregistrement, l'Agent a utilisé 34 000 jetons.",[10,1573,1574],{},"Dans notre exemple, la spécification OpenAPI contient 89 105 caractères, soit environ 22 000 jetons avec la même approximation de quatre caractères par jeton.",[10,1576,1577],{},"Essayons maintenant quelques exemples pour mesurer le nombre de jetons nécessaires au modèle avec notre MCP Code Mode.",[608,1579,1580,1599,1626,1644],{},[611,1581,1582,1583,1589],{},"« Liste les demandes de retour au statut requested pour le vendeur seller-aurora, triées de la plus récemment mise à jour à la plus ancienne, et renvoie les 10 premiers résultats. »",[1584,1585,1586],"ul",{},[611,1587,1588],{},"18 100 jetons",[1115,1590,1117,1591,1117,1596],{},[1119,1592,1121,1593,1117],{"autoPlay":772,"loop":772,"muted":772,"playsInline":772},[1123,1594],{"src":1595,"type":1126},"https:\u002F\u002Fimages.soubiran.dev\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters\u002Flist-return-requests.mp4",[1128,1597,1598],{},"Liste des demandes de retour d'un vendeur avec le Code Mode.",[611,1600,1601,1602,1607,1608,1613,1614],{},"« Crée un vendeur en attente nommé North Star Living, avec le slug north-star-living et l'adresse ",[1603,1604,1606],"a",{"href":1605},"mailto:hello@north-star-living.example","hello@north-star-living.example",". »",[1584,1609,1610],{},[611,1611,1612],{},"16 900 jetons","\n ",[1115,1615,1616,1617,1616,1623,1613],{},"\n   ",[1119,1618,1619,1620,1616],{"autoPlay":772,"loop":772,"muted":772,"playsInline":772},"\n     ",[1123,1621],{"src":1622,"type":1126},"https:\u002F\u002Fimages.soubiran.dev\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters\u002Fcreate-pending-seller.mp4",[1128,1624,1625],{},"Création d'un vendeur en attente avec le Code Mode.",[611,1627,1628,1629,1613,1634],{},"« Publie le produit product-desk-lamp en passant son statut à active. »",[1584,1630,1631],{},[611,1632,1633],{},"17 800 jetons",[1115,1635,1616,1636,1616,1641,1613],{},[1119,1637,1619,1638,1616],{"autoPlay":772,"loop":772,"muted":772,"playsInline":772},[1123,1639],{"src":1640,"type":1126},"https:\u002F\u002Fimages.soubiran.dev\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters\u002Fpublish-product.mp4",[1128,1642,1643],{},"Publication d'un produit avec le Code Mode.",[611,1645,1646,1647,1613,1652],{},"« Supprime le produit product-desk-lamp. »",[1584,1648,1649],{},[611,1650,1651],{},"17 500 jetons",[1115,1653,1616,1654,1616,1659,1613],{},[1119,1655,1619,1656,1616],{"autoPlay":772,"loop":772,"muted":772,"playsInline":772},[1123,1657],{"src":1658,"type":1126},"https:\u002F\u002Fimages.soubiran.dev\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters\u002Fremove-product.mp4",[1128,1660,1661],{},"Suppression d'un produit avec le Code Mode.",[10,1663,1664],{},"Ces mesures proviennent d'un environnement local de test. Il ne s'agit pas d'un véritable benchmark. Retenez surtout que le modèle n'a pas besoin de toute la description de l'API pour interagir avec elle. Il construit son contexte à partir des seules informations nécessaires.",[17,1666,1668],{"id":1667},"vers-une-exécution-plus-sûre","Vers une exécution plus sûre",[10,1670,1671],{},"Nous avons donné au modèle un outil pour rechercher dans la spécification OpenAPI. Il peut désormais exécuter lui-même les appels API et ne renvoyer que les données utiles. Mais est-ce sûr ?",[10,1673,1674,1675,1678],{},"Le code du modèle n'est pas fiable. C'est la première règle de la sécurité web : ne jamais faire confiance aux entrées utilisateur. Ici, le code généré par le modèle est une entrée utilisateur exécutée par un évaluateur local de confiance basé sur le constructeur ",[33,1676,1677],{},"Function",". Dans le prochain article, nous verrons comment rendre cette exécution plus sûre grâce à un environnement dédié.",[1680,1681,1682],"style",{},"html pre.shiki code .sxrX7, html code.shiki .sxrX7{--shiki-light:#24292E;--shiki-default:#24292E;--shiki-dark:#E1E4E8}html pre.shiki code .sBjJW, html code.shiki .sBjJW{--shiki-light:#005CC5;--shiki-default:#005CC5;--shiki-dark:#79B8FF}html pre.shiki code .sIIMD, html code.shiki .sIIMD{--shiki-light:#032F62;--shiki-default:#032F62;--shiki-dark:#9ECBFF}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 .s8jYJ, html code.shiki .s8jYJ{--shiki-light:#D73A49;--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .snPdu, html code.shiki .snPdu{--shiki-light:#6F42C1;--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .sP4rz, html code.shiki .sP4rz{--shiki-light:#E36209;--shiki-default:#E36209;--shiki-dark:#FFAB70}",{"title":31,"searchDepth":46,"depth":46,"links":1684},[1685,1686,1687,1688,1689],{"id":19,"depth":46,"text":20},{"id":276,"depth":46,"text":277},{"id":1133,"depth":46,"text":1134},{"id":1489,"depth":46,"text":1490},{"id":1667,"depth":46,"text":1668},"5097481f-e94c-409c-865b-78f9bbf83a68","2026-07-12","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.","md",{"branch":1695},"part-4-local-execute",null,{},"\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters","---\ncontentId: 5097481f-e94c-409c-865b-78f9bbf83a68\npart: 4\ntitle: Appeler des API avec le Code Mode et garder l'essentiel\ndescription: 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.\ngithub:\n  branch: part-4-local-execute\ndate: 2026-07-12\nseriesSlug: building-code-mode-for-apis-with-mcp-and-isolated-workers\n---\n\nNous avons vu comment laisser le modèle écrire du code JavaScript pour rechercher dans une spécification OpenAPI plus volumineuse que la fenêtre de contexte. La spécification peut continuer à grandir, même si l'environnement d'exécution conserve des limites concrètes sur le temps d'exécution, la mémoire et les données renvoyées.\n\nVoyons maintenant comment laisser le modèle écrire du JavaScript pour interagir avec notre API à partir des connaissances recueillies dans la spécification OpenAPI.\n\n## Notre MCP a besoin d'un deuxième outil\n\nNotre objectif était de créer un système qui facilite les interactions entre le LLM et notre API. Pour le moment, notre LLM peut explorer et comprendre l'API :\n\n```json [LLM Tool Call]\n{\n  \"code\": \"async () => {\\n  const results = [];\\n  for (const [path, methods] of Object.entries(spec.paths)) {\\n    for (const [method, operation] of Object.entries(methods)) {\\n      if (operation?.tags?.some(tag => tag.toLowerCase() === 'returns')) {\\n        results.push({\\n          method: method.toUpperCase(),\\n          path,\\n          operationId: operation.operationId,\\n          summary: operation.summary,\\n          description: operation.description,\\n          parameters: operation.parameters,\\n          requestBody: operation.requestBody,\\n        });\\n      }\\n    }\\n  }\\n  return results;\\n}\"\n}\n```\n\n```json [LLM Tool Output]\n[\n  {\n    \"method\": \"GET\",\n    \"path\": \"\u002Freturns\",\n    \"operationId\": \"listReturns\",\n    \"summary\": \"List return requests\",\n    \"description\": \"List return requests, optionally narrowed to an order, order item, seller, or return status.\",\n    \"parameters\": [],\n    \"requestBody\": null\n  }\n]\n```\n\nIl ne peut toutefois pas encore interagir avec elle.\n\nNous devons pour cela lui fournir un deuxième outil : l'exécuteur.\n\n## L'outil d'exécution\n\nL'outil d'exécution complète l'outil de recherche. Sous le capot, il enveloppe un client API préconfiguré, ici une fonction `fetch`, qui permet au modèle d'appeler l'API grâce aux informations recueillies dans la spécification OpenAPI.\n\nDans les grandes lignes, il ressemble beaucoup à l'outil de recherche. Nous fournissons au modèle un environnement préconfiguré dans lequel écrire du code pour une API typée et prédéfinie. Le modèle orchestre une ou plusieurs requêtes selon la complexité de la tâche, puis ne renvoie que les données utiles.\n\n```typescript [executor.ts]\nexport function registerExecuteTool(server: McpServer): void {\n  server.registerTool(\n    'execute',\n    {\n      title: 'MarketHub API Code Executor',\n      description: '...',\n      inputSchema: z.object({\n        code: z\n          .string()\n          .max(MAX_CODE_LENGTH)\n          .describe('An async arrow function that executes a MarketHub API request')\n      }),\n    },\n    async ({ code }) => {\n      try {\n        const result = await evaluateExecuteCode(code)\n        return { content: [{ type: 'text', text: formatExecuteResult(result) }] }\n      }\n      catch (error) {\n        return {\n          content: [{ type: 'text', text: `Execute failed: ${errorMessage(error)}` }],\n          isError: true\n        }\n      }\n    }\n  )\n}\n```\n\nLa ressemblance avec l'outil de recherche saute aux yeux. Nous recevons une fonction fléchée JavaScript, nous l'évaluons et nous renvoyons son résultat.\n\nDeux différences comptent :\n\n1. La description indique au modèle qu'il peut écrire du code pour l'API et qu'il doit ne renvoyer que les données utiles.\n2. Nous utilisons `evaluateExecuteCode` au lieu de `evaluateSearchCode`. Les deux fonctions évaluent du code, mais les données disponibles dans leur contexte diffèrent.\n\nLa description commence par expliquer brièvement le rôle de l'outil.\n\n```text [Exemple]\nExecute JavaScript code against the local MarketHub API.\n\nFirst use the 'search' tool to find the right endpoint, method, parameters, and request body, then write code using api.request().\n```\n\nElle fournit ensuite une interface TypeScript qui indique précisément au modèle comment écrire son code.\n\n```typescript [Exemple]\ninterface ApiRequestOptions {\n  method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'\n  path: string\n  query?: Record\u003Cstring, string | number | boolean | undefined>\n  body?: unknown\n  contentType?: string\n  rawBody?: boolean\n}\n\ninterface ApiResponse\u003CT = unknown> {\n  success: boolean\n  status: number\n  result: T\n  errors: Array\u003C{ code: string | number, message: string }>\n  messages: Array\u003C{ code: string | number, message: string }>\n}\n\ndeclare const api: {\n  request: \u003CT = unknown>(options: ApiRequestOptions) => Promise\u003CApiResponse\u003CT>>\n}\n```\n\nNous pouvons maintenant écrire du code pour l'API. L'interface `ApiRequestOptions` montre clairement que nous ne faisons rien de plus qu'envelopper `fetch`. Les paramètres sont presque identiques, mais simplifiés pour ne présenter au modèle que les informations nécessaires. Pour la réponse, nous préparons les données afin de réduire le travail du modèle.\n\nEnfin, la description contient un petit exemple d'utilisation de l'outil.\n\n```typescript [Exemple]\nasync () => {\n  const response = await api.request({\n    method: 'GET',\n    path: '\u002Fproducts',\n    query: { 'status:eq': 'active', '_per_page': 5 }\n  })\n\n  return response.result.map(product => ({\n    id: product.id,\n    name: product.name,\n    status: product.status\n  }))\n}\n```\n\n\u003Cfigure>\n  \u003Cvideo autoplay loop muted playsinline>\n    \u003Csource src=\"https:\u002F\u002Fimages.soubiran.dev\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters\u002Fexecute-api-request.mp4\" type=\"video\u002Fmp4\">\n  \u003C\u002Fvideo>\n  \u003Cfigcaption>Exécution d'une requête API qui ne renvoie que les champs sélectionnés pour les produits.\u003C\u002Ffigcaption>\n\u003C\u002Ffigure>\n\n## Code Mode ou simple appel d'outil\n\nVous vous demandez peut-être pourquoi ne pas simplement fournir au modèle un appel d'outil classique, comme nous le faisons pour la plupart des MCP. Nous pourrions par exemple imaginer un outil nommé `list_returns` qui recevrait l'identifiant d'un vendeur et renverrait la liste des retours. Le modèle n'aurait qu'à l'appeler avec les bons paramètres pour obtenir le résultat.\n\nVous avez raison. Nous aurions pu procéder ainsi. Mais une API de 150 endpoints nécessiterait 150 outils. Nous pourrions réduire ce nombre en regroupant certains endpoints derrière un paramètre, comme le fait le MCP de GitHub. Son outil `pull_request_read` possède par exemple un paramètre `method` qui accepte les valeurs `get`, `get_diff`, `get_status`, `get_files`, `get_commits`, `get_review_comments`, `get_reviews`, `get_comments` et `get_check_runs`. Je vous laisse imaginer la complexité sous-jacente et le casse-tête du regroupement. Si GitHub ajoute une méthode demain, son MCP doit être mis à jour.\n\nLe Code Mode permet aussi au modèle d'adapter l'entrée et la sortie de la requête. S'il sait qu'un endpoint renvoie une réponse très détaillée, il peut ne conserver que les champs nécessaires. Il peut également enchaîner les requêtes, créer des boucles, utiliser des conditions, réessayer lorsque le résultat ne correspond pas à ses attentes, etc. Le modèle orchestre librement la requête selon ses besoins.\n\n```typescript [Exemple]\nasync () => {\n  const sellers = (await api.request({\n    method: 'GET',\n    path: '\u002Fsellers',\n    query: { 'status:eq': 'active', '_per_page': 5 }\n  })).result\n\n  const results = []\n\n  for (const seller of sellers) {\n    const products = (await api.request({\n      method: 'GET',\n      path: '\u002Fproducts',\n      query: {\n        sellerId: seller.id,\n        _embed: 'variants',\n        _per_page: 10\n      }\n    })).result\n\n    for (const product of products) {\n      for (const variant of product.variants ?? []) {\n        results.push({\n          seller: seller.name,\n          product: product.name,\n          sku: variant.sku\n        })\n      }\n    }\n  }\n\n  return results\n}\n```\n\nAvec des appels d'outils directs, ce processus nécessite plusieurs allers-retours avec l'Agent. Le modèle reçoit chaque résultat, décide de la suite et envoie un nouvel appel. Le Code Mode conserve le contrôle du flux, le filtrage et la préparation du résultat dans le programme généré.\n\n## Ne renvoyer que les données utiles\n\nAvec un peu de recul, cette approche peut sembler inutilement complexe. Comparons les deux options avant d'étudier les mesures en jetons.\n\nL'instantané OpenAPI de Cloudflare utilisé dans cette série contient 23 792 523 caractères. Une division par quatre donne une estimation d'environ 6 millions de jetons, même si le nombre exact varie selon le modèle et le contenu.\n\n| Point étudié | Appels d'outils directs | Code Mode |\n| --- | --- | --- |\n| Tâches dépendantes | Le modèle reçoit chaque résultat intermédiaire avant de choisir l'appel suivant. | Le programme généré transmet les valeurs intermédiaires entre les appels et ne renvoie que sa projection finale. |\n| API volumineuse | Le serveur doit exposer et documenter un ensemble d'outils parmi lesquels le modèle choisit. | Le modèle peut rechercher dans une spécification conservée côté serveur, puis composer les appels ciblés dont il a besoin. |\n| Préparation des données | Le modèle reçoit souvent la réponse de chaque outil avant de pouvoir la réduire. | Le programme généré peut filtrer, agréger et projeter les données avant de les renvoyer. |\n\nUn serveur d'outils directs bien conçu peut lui aussi traiter les données par lots et garder des réponses compactes. Le Code Mode devient surtout utile lorsqu'une tâche nécessite des appels dépendants, un traitement local ou une API qui évolue.\n\nPour l'illustrer, demandons à notre Agent de lister les 10 Workers qui consomment le plus de CPU :\n\n\u003Cfigure>\n  \u003Cvideo autoplay loop muted playsinline>\n    \u003Csource src=\"https:\u002F\u002Fimages.soubiran.dev\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters\u002Flist-top-cpu-intensive-workers.mp4\" type=\"video\u002Fmp4\">\n  \u003C\u002Fvideo>\n  \u003Cfigcaption>Liste des 10 Workers qui consomment le plus de CPU avec le Code Mode.\u003C\u002Ffigcaption>\n\u003C\u002Ffigure>\n\nLors de cet enregistrement, l'Agent a utilisé 34 000 jetons.\n\nDans notre exemple, la spécification OpenAPI contient 89 105 caractères, soit environ 22 000 jetons avec la même approximation de quatre caractères par jeton.\n\nEssayons maintenant quelques exemples pour mesurer le nombre de jetons nécessaires au modèle avec notre MCP Code Mode.\n\n1. « Liste les demandes de retour au statut requested pour le vendeur seller-aurora, triées de la plus récemment mise à jour à la plus ancienne, et renvoie les 10 premiers résultats. »\n\n   - 18 100 jetons\n\n   \u003Cfigure>\n     \u003Cvideo autoplay loop muted playsinline>\n       \u003Csource src=\"https:\u002F\u002Fimages.soubiran.dev\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters\u002Flist-return-requests.mp4\" type=\"video\u002Fmp4\">\n     \u003C\u002Fvideo>\n     \u003Cfigcaption>Liste des demandes de retour d'un vendeur avec le Code Mode.\u003C\u002Ffigcaption>\n   \u003C\u002Ffigure>\n\n2. « Crée un vendeur en attente nommé North Star Living, avec le slug north-star-living et l'adresse hello@north-star-living.example. »\n\n    - 16 900 jetons\n\n    \u003Cfigure>\n      \u003Cvideo autoplay loop muted playsinline>\n        \u003Csource src=\"https:\u002F\u002Fimages.soubiran.dev\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters\u002Fcreate-pending-seller.mp4\" type=\"video\u002Fmp4\">\n      \u003C\u002Fvideo>\n      \u003Cfigcaption>Création d'un vendeur en attente avec le Code Mode.\u003C\u002Ffigcaption>\n    \u003C\u002Ffigure>\n\n3. « Publie le produit product-desk-lamp en passant son statut à active. »\n\n    - 17 800 jetons\n\n    \u003Cfigure>\n      \u003Cvideo autoplay loop muted playsinline>\n        \u003Csource src=\"https:\u002F\u002Fimages.soubiran.dev\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters\u002Fpublish-product.mp4\" type=\"video\u002Fmp4\">\n      \u003C\u002Fvideo>\n      \u003Cfigcaption>Publication d'un produit avec le Code Mode.\u003C\u002Ffigcaption>\n    \u003C\u002Ffigure>\n\n4. « Supprime le produit product-desk-lamp. »\n\n    - 17 500 jetons\n\n    \u003Cfigure>\n      \u003Cvideo autoplay loop muted playsinline>\n        \u003Csource src=\"https:\u002F\u002Fimages.soubiran.dev\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters\u002Fremove-product.mp4\" type=\"video\u002Fmp4\">\n      \u003C\u002Fvideo>\n      \u003Cfigcaption>Suppression d'un produit avec le Code Mode.\u003C\u002Ffigcaption>\n    \u003C\u002Ffigure>\n\nCes mesures proviennent d'un environnement local de test. Il ne s'agit pas d'un véritable benchmark. Retenez surtout que le modèle n'a pas besoin de toute la description de l'API pour interagir avec elle. Il construit son contexte à partir des seules informations nécessaires.\n\n## Vers une exécution plus sûre\n\nNous avons donné au modèle un outil pour rechercher dans la spécification OpenAPI. Il peut désormais exécuter lui-même les appels API et ne renvoyer que les données utiles. Mais est-ce sûr ?\n\nLe code du modèle n'est pas fiable. C'est la première règle de la sécurité web : ne jamais faire confiance aux entrées utilisateur. Ici, le code généré par le modèle est une entrée utilisateur exécutée par un évaluateur local de confiance basé sur le constructeur `Function`. Dans le prochain article, nous verrons comment rendre cette exécution plus sûre grâce à un environnement dédié.\n",{"title":5,"description":1692},"building-code-mode-for-apis-with-mcp-and-isolated-workers",{"loc":1698},"fr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fcalling-apis-with-code-mode-and-returning-only-what-matters","9uu-McEhWBHzD8A1qKei7bTiDWw4MudNuZc1fXsAXKk",{"overview":1706,"chapters":1874},{"id":1707,"title":1708,"body":1709,"contentId":1855,"date":1691,"description":1856,"extension":1693,"github":1857,"meetTheInstructor":1858,"meta":1859,"navigation":772,"part":1696,"path":1860,"rawbody":1861,"robots":1696,"schemaOrg":1696,"seo":1862,"seriesSlug":1701,"sitemap":1863,"stem":1864,"subtitle":1865,"topics":1866,"__hash__":1873},"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":1710,"toc":1852},[1711,1714,1722,1728,1741,1757,1760,1763,1766,1823,1831,1842,1846],[10,1712,1713],{},"Bonjour et bienvenue ! 👋",[10,1715,1716,1717,1721],{},"Cette série prolonge de manière concrète l'article ",[1603,1718,1720],{"href":1719},"\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,1723,1724,1725,1727],{},"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 ",[33,1726,1677],{}," 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,1729,1730,1731,1735,1736,1740],{},"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 ",[1603,1732,1734],{"href":1733},"\u002Ffr\u002Fseries\u002Fai-agents-and-mcp-server-teaming-up-for-the-agentic-web","Agents IA et serveur MCP au service du web agentique",", en particulier ",[1603,1737,1739],{"href":1738},"\u002Ffr\u002Fseries\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,1742,1743,1744,1748,1749,1752,1753,1756],{},"Tout au long de la série, le ",[1745,1746,1747],"strong",{},"modèle"," génère des appels d'outils ou du code, le ",[1745,1750,1751],{},"client MCP"," ou Agent exécute la boucle du modèle et le ",[1745,1754,1755],{},"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,1758,1759],{},"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,1761,1762],{},"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,1764,1765],{},"Au fil de cette série, nous allons :",[608,1767,1768,1778,1793,1803,1817],{},[611,1769,1770,1773,1774,1777],{},[1745,1771,1772],{},"Au-delà d'un appel d'outil à la fois : découvrir le Code Mode"," : construire deux outils ",[33,1775,1776],{},"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.",[611,1779,1780,1783,1784,1786,1787,1789,1790,1792],{},[1745,1781,1782],{},"Laisser le modèle orchestrer les outils dans un environnement local"," : remplacer les deux outils directs par un outil ",[33,1785,33],{}," générique, exposer une façade ",[33,1788,1776],{}," typée et introduire l'interface de l'exécuteur que les parties suivantes remplaceront. L'évaluateur local basé sur le constructeur ",[33,1791,1677],{}," est volontairement un raccourci réservé au développement de confiance, et non un bac à sable de production.",[611,1794,1795,1798,1799,1802],{},[1745,1796,1797],{},"Rechercher dans une spécification OpenAPI sans remplir le contexte"," : conserver le document OpenAPI dans le serveur, résoudre ses références ",[33,1800,1801],{},"$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.",[611,1804,1805,1808,1809,1812,1813,1816],{},[1745,1806,1807],{},"Appeler des API avec le Code Mode et ne renvoyer que l'essentiel"," : ajouter un outil ",[33,1810,1811],{},"execute"," distinct avec une fonction ",[33,1814,1815],{},"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.",[611,1818,1819,1822],{},[1745,1820,1821],{},"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,1824,1825,1826,1830],{},"Le dépôt associé, ",[1827,1828],"git-hub-link",{"repo":1829},"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.",[1832,1833,1836],"callout",{"color":1834,"icon":1835},"info","i-ph-info-duotone",[10,1837,1838,1839,1841],{},"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 ",[33,1840,1677],{}," pour le développement. La partie 5 fournit une base de déploiement Cloudflare et une évaluation structurelle de la sécurité.",[17,1843,1845],{"id":1844},"chapitres","Chapitres",[1847,1848],"series-chapters-list",{"className":1849},[1850,1851],"mx-auto","max-w-5xl",{"title":31,"searchDepth":46,"depth":46,"links":1853},[1854],{"id":1844,"depth":46,"text":1845},"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":1515,"repository":1829},"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":1708,"description":1856},{"loc":1860},"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",[1867,1868,1869,1870,1871,1872,293],"ai","ai-agents","mcp","code-mode","openapi","cloudflare","HqoFmkgNETmMSWXeXg8BeVY4Vjz1w13UtWu2_6vvVaE",[1875,1882,1889,1896,1898],{"contentId":1876,"title":1877,"description":1878,"path":1879,"part":39,"github":1880,"topics":1696},"02726224-2677-4d4b-9390-cf6543caba80","Au-delà d'un appel d'outil : découvrir le Code Mode","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.","\u002Ffr\u002Fseries\u002Fbuilding-code-mode-for-apis-with-mcp-and-isolated-workers\u002Fbeyond-one-tool-call-at-a-time-introducing-code-mode",{"branch":1881},"part-1-direct-tools",{"contentId":1883,"title":1884,"description":1885,"path":1886,"part":46,"github":1887,"topics":1696},"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":1888},"part-2-generic-code-mode",{"contentId":1890,"title":1891,"description":1892,"path":1893,"part":151,"github":1894,"topics":1696},"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":1895},"part-3-search",{"contentId":1690,"title":5,"description":1692,"path":1698,"part":186,"github":1897,"topics":1696},{"branch":1695},{"contentId":1899,"title":1821,"description":1900,"path":1901,"part":199,"github":1902,"topics":1696},"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":1903},"part-5-dynamic-workers",1795016702381]