For AI agents: The documentation index is at https://docs.digitalocean.com/llms.txt. Markdown versions of pages use the same URL with index.html.md in place of the HTML page (for example, append index.html.md to the directory path instead of opening the HTML document).

Server-side tools are capabilities you attach to an inference request that the Inference platform runs for you during the model turn. When the model decides to use a tool, the platform executes it and folds the result back into the conversation. Server-side tools differ from client-side tools, where the model returns which tool to call and with which arguments, and your app runs the function and sends the result back in a follow-up request.

We support server-side integrations that extend the model’s capabilities during inference. Instead of managing tool orchestration yourself, you add tool definitions in your API request and the platform handles discovery, execution, and response integration automatically. You can use the following server-side tools with serverless inference, dedicated inference, and inference routers:

Web Search, Web Fetch for non-Anthropic models, Model Synthesis, Knowledge Base Retrieval, and MCP are DigitalOcean-hosted server-side tools. Passthrough tools to the provider include Tool Search, Computer Use, Bash, Local Shell, Web Fetch, and Text Editor.

For pricing information, see Tools Usage Pricing.

Get Started

Server-side tools work with both the Chat Completions API and the Responses API, and with the Messages API for Anthropic models. To use server-side tools, add the tool definitions to the tools array in your API request. Set tool_choice to auto to let the model decide when to query a tool, or required to always query it before responding.

To use tools with an inference router and dedicated inference deployments, set the model field to the name of your router or dedicated inference and model slug, respectively.

To use tools with dedicated inference and inference routers, update the model field, as described in Use Dedicated Inference and Use Inference Router.

The following example sends a Responses API request with knowledge base retrieval and web search tools enabled for serverless inference:

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.responses.create(
    model="deepseek-v4-pro",
    input="What is actions infrastructure? Answer using the knowledge base and search the web for real-time information.",
    tools=[
        {
            "type": "knowledge_base_retrieval",
            "knowledge_base_id": "09d65da1-5225-11f1-b074-4e013e2xxxx",
        },
        {
            "type": "web_search",
            "max_uses": 3,
            "max_results": 5,
        },
    ],
    stream=False,
    max_output_tokens=1024,
)

print(resp)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const resp = await client.responses.create({
    model: "deepseek-v4-pro",
    input: "What is actions infrastructure? Answer using the knowledge base and search the web for real-time information.",
    tools: [
        {
            type: "knowledge_base_retrieval",
            knowledge_base_id: "09d65da1-5225-11f1-b074-4e013e2xxxx",
        },
        {
            type: "web_search",
            max_uses: 3,
            max_results: 5,
        },
    ],
    stream: false,
    max_output_tokens: 1024,
});

console.log(resp);

curl -X POST https://inference.do-ai.run/v1/responses \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "input": "What is actions infrastructure? Answer using the knowledge base and search the web for real-time information.",
    "tools": [
      {
        "type": "knowledge_base_retrieval",
        "knowledge_base_id": "09d65da1-5225-11f1-b074-4e013e2xxxx"
      },
      {
        "type": "web_search",
        "max_uses": 3,
        "max_results": 5
      }
    ],
    "stream": false,
    "max_output_tokens": 1024
  }'

Use Web Search public

Web search is a built-in tool that gives the model access to real-time web content during inference. When you add web search in your API request, the model decides when a web search is needed, and the results are incorporated into the model’s response.

We use a third-party web search service (Exa.ai) for all models.

To enable web search, include a tool object with type set to web_search in the tools array of your request. When the model determines that a prompt benefits from web search, it searches for relevant information and incorporates the results into its response.

The following examples send Responses API requests with web search enabled:

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.responses.create(
    model="openai-gpt-4o",
    input="What are the latest pricing changes for DigitalOcean Droplets?",
    tools=[
        {
            "type": "web_search",
            "max_uses": 3,
            "max_results": 5,
        }
    ],
    max_output_tokens=1024,
    stream=False,
)

print(resp)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const resp = await client.responses.create({
    model: "openai-gpt-4o",
    input: "What are the latest pricing changes for DigitalOcean Droplets?",
    tools: [
        {
            type: "web_search",
            max_uses: 3,
            max_results: 5,
        },
    ],
    max_output_tokens: 1024,
    stream: false,
});

console.log(resp);

curl -X POST https://inference.do-ai.run/v1/responses \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai-gpt-4o",
    "input": "What are the latest pricing changes for DigitalOcean Droplets?",
    "tools": [
      {
        "type": "web_search",
        "max_uses": 3,
        "max_results": 5
      }
    ],
    "max_output_tokens": 1024,
    "stream": false
  }'

Alternatively, specify model: <model_name>:web to enable model access to web search and web fetch. This is particularly useful in coding agents where you can only change the model name.

You can optionally limit the number of searches the model performs per request from 1 to 5 with max_uses and the number of results each search returns from 1 to 10 with max_results (defaults to 5). When the request reaches the limit, the model produces a final response using the results collected so far. For the full set of web search parameters, see the Serverless Inference API reference.

The response looks similar to the following:

{
  ...
  "output": [
    {
      "action": {
        "queries": [
          "DigitalOcean AI platform features"
        ],
        "query": "DigitalOcean AI platform features",
        "type": "search"
      },
      "id": "ws_call_t7eyYNbAWQOcEln1Ns2TxuOv",
      "status": "completed",
      "type": "web_search_call"
    },
    {
      "content": [
        {
          "annotations": [
            {
              "end_index": 1501,
              "start_index": 1439,
              "title": "DigitalOcean AI Platform Features | DigitalOcean Documentation",
              "type": "url_citation",
              "url": "https://docs.digitalocean.com/products/inference/details/features"
            },
            {
              "end_index": 1800,
              "start_index": 1729,
              "title": "DigitalOcean Inference Details | DigitalOcean Documentation",
              "type": "url_citation",
              "url": "https://docs.digitalocean.com/products/inference/details"
            },
            {
              "end_index": 2085,
              "start_index": 2028,
              "title": "Agent Platform | Build AI Agents with DigitalOcean",
              "type": "url_citation",
              "url": "https://www.digitalocean.com/products/inference/platform"
            }
          ],
          "logprobs": [],
          "text": "The DigitalOcean AI Platform offers a variety of features:\n\n1. **AI Agent Development**: Build fully-managed AI ...",
          "type": "output_text"
        }
      ],
...
  }
}

Use Web Fetch public

Web fetch is a built-in tool that retrieves the full content of specific web pages and PDF documents during inference. When you add web fetch to your API request, the model fetches URLs referenced in the conversation and incorporates the content into its response.

We use a third-party web fetch service (Exa.ai) for non-Anthropic models. For Anthropic models, requests pass through to Anthropic’s web fetch service.

To enable web fetch, include a tool object with type set to web_fetch in the tools array of your request. The following example sends a Responses API request with web fetch enabled:

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.responses.create(
    model="openai-gpt-4o",
    input="Summarize the content at https://docs.digitalocean.com/products/inference/",
    tools=[
        {
            "type": "web_fetch",
            "max_uses": 3,
        }
    ],
    max_output_tokens=1024,
    stream=False,
)

print(resp)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const resp = await client.responses.create({
    model: "openai-gpt-4o",
    input: "Summarize the content at https://docs.digitalocean.com/products/inference/",
    tools: [
        {
            type: "web_fetch",
            max_uses: 3,
        },
    ],
    max_output_tokens: 1024,
    stream: false,
});

console.log(resp);

curl -X POST https://inference.do-ai.run/v1/responses \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai-gpt-4o",
    "input": "Summarize the content at https://docs.digitalocean.com/products/inference/",
    "tools": [
      {
        "type": "web_fetch",
        "max_uses": 3
      }
    ],
    "max_output_tokens": 1024,
    "stream": false
  }'

You can optionally limit the number of fetches the model performs per request from 1 to 5 with max_uses. When the request reaches the limit, the model produces a final response using the content collected so far.

Alternatively, specify model: <model_name>:web to give the model access to web fetch and web search. This is particularly useful for coding agents where you can only change the model name.

Use the Model Synthesis Tool public

The model synthesis tool (API only) is a multi-model tool that runs multiple models on the same task and returns one synthesized answer. You can choose up to eight analysis models that work independently in parallel, plus a top-level model that produces the final completion returned to your application. Each panel model can answer from its training knowledge and, when useful, call server-side web search and web fetch within limits you configure.

The model synthesis tool runs three server-side steps:

1. Analyze: Panel models receive the same task and answer in parallel.
2. Judge: A judge model compares panel results, evidence, gaps, and conflicts.
3. Synthesize: The top-level request model writes the final user-facing answer.

The top-level model in your API request is the outer model that returns the final completion. By default, it also acts as the judge. Set model on the model synthesis tool object to designate a different judge.

The model synthesis tool differs from Inference Router, which routes a request to a single best-fit model. The model synthesis tool intentionally asks several models to address the same problem, then judges and synthesizes their work. Use the model synthesis tool when multiple perspectives justify additional time and cost. Use a single model or a router when you need low latency, deterministic workflows, or routine extraction and classification.

The model synthesis tool works with the Chat Completions API, the Responses API, and the Messages API for Anthropic models. You can use the model synthesis tool with serverless inference, dedicated inference, and inference routers by setting the top-level model field accordingly. Add a tool object with type set to model_synthesis in the tools array. Existing pydo and @digitalocean/dots clients pass the model synthesis tool object through without SDK changes.

The application receives a normal completion from the top-level model. You do not need a separate multi-agent response format or client-side orchestration code.

When to Use the Model Synthesis Tool

Use the model synthesis tool for consequential comparisons, ambiguous research, technical or strategic decisions, complex troubleshooting, architecture and vendor evaluations, policy analysis, and incident retrospectives. Tasks where missed considerations are costly benefit from independent panel attempts and disciplined synthesis.

The model synthesis tool is not intended for every request. Text rewriting, data extraction, label classification, and interactions with strict latency or cost limits are usually better served by a single model.

Configure the Model Synthesis Tool

You can configure the model synthesis tool with a DigitalOcean preset, or set the synthesizer, panel, judge, and reasoning settings yourself. Use model slugs from the available models page for analysis_models, the model synthesis tool model field (judge), and the top-level request model.

Any model available for DigitalOcean Inference can act as a panel member or judge. Commercial models from OpenAI and Anthropic follow the same third-party model access restrictions as other inference features. When you configure the panel directly, tune it for the workload: a high-quality panel for critical analysis, a lower-cost panel for routine research, or a diverse mix to reduce shared reasoning gaps. More panel models increase cost and may increase latency. Start with a small, task-relevant panel and add models only when evaluation shows measurable value.

Use a Preset

Use DigitalOcean presets for common quality and cost tradeoffs without selecting panel models yourself:

DigitalOcean Inference resolves each preset to a validated synthesizer, model panel, and reasoning configuration. As models, pricing, and performance improve, the underlying configuration can be updated without requiring changes to your integration.

When you set preset, omit analysis_models. Specifying both returns HTTP 400. You can still set reasoning_effort, max_tokens, and max_tool_calls on the tool object to override the preset defaults for those fields.

The following Chat Completions example uses the balanced preset:

curl -X POST https://inference.do-ai.run/v1/chat/completions \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.2",
    "messages": [
      {
        "role": "user",
        "content": "Your research question here"
      }
    ],
    "tools": [
      {
        "type": "model_synthesis",
        "preset": "balanced"
      }
    ]
  }'

Configure Directly

When you configure the model synthesis tool directly, the top-level model is the synthesizer that returns the final completion. The analysis_models list on the tool object is the panel. Set model on the tool object to designate a judge that differs from the synthesizer; when omitted, the judge defaults to the top-level request model.

Set reasoning_effort in two places when you need separate control: the top-level value applies to the synthesizer, and the value on the tool object applies to panel models and the judge.

The following Chat Completions example sets the synthesizer, panel, judge, and reasoning effort directly:

curl -X POST https://inference.do-ai.run/v1/chat/completions \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.2",
    "messages": [
      {
        "role": "user",
        "content": "Your research question here"
      }
    ],
    "reasoning_effort": "high",
    "tools": [
      {
        "type": "model_synthesis",
        "model": "glm-5.2",
        "analysis_models": [
          "glm-5.2",
          "kimi-k2.6"
        ],
        "reasoning_effort": "high"
      }
    ]
  }'

Set reasoning_effort on the model synthesis tool object for all APIs. Chat Completions accepts none, minimal, low, medium, high, and xhigh. Responses accepts none, low, medium, high, and xhigh. Messages uses the same field on the tool object. The value is forwarded to each panel and judge sub-call. On Chat Completions, you can also set top-level reasoning_effort for the synthesizer. If a target model’s catalog metadata does not support the effort you set, the value is dropped silently. Anthropic maps minimal to low and xhigh to max. Accepted values are ultimately per model from catalog metadata, not a fixed list per provider.

Send a Model Synthesis Tool Request

The following examples send model synthesis tool requests on the Chat Completions, Responses, and Messages APIs. In each case, the top-level model synthesizes the final answer after the panel models and judge complete their work.

Chat Completions API

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.chat.completions.create(
    model="anthropic-claude-opus-4.8",
    messages=[
        {
            "role": "user",
            "content": (
                "Compare Kubernetes and Nomad for a small platform team running "
                "20 internal services. Give a concise recommendation with tradeoffs."
            ),
        },
    ],
    tools=[
        {
            "type": "model_synthesis",
            "analysis_models": [
                "openai-gpt-5.5",
                "deepseek-v4-pro",
            ],
            "max_tool_calls": 8,
            "max_tokens": 16000,
        }
    ],
    tool_choice="required",
    max_tokens=16000,
    stream=False,
)

print(resp.choices[0].message.content)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const completion = await client.chat.completions.create({
    model: "anthropic-claude-opus-4.8",
    messages: [
        {
            role: "user",
            content:
                "Compare Kubernetes and Nomad for a small platform team running " +
                "20 internal services. Give a concise recommendation with tradeoffs.",
        },
    ],
    tools: [
        {
            type: "model_synthesis",
            analysis_models: ["openai-gpt-5.5", "deepseek-v4-pro"],
            max_tool_calls: 8,
            max_tokens: 16000,
        },
    ],
    tool_choice: "required",
    max_tokens: 16000,
    stream: false,
});

console.log(completion.choices[0].message.content);

curl -X POST https://inference.do-ai.run/v1/chat/completions \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic-claude-opus-4.8",
    "messages": [
      {
        "role": "user",
        "content": "Compare Kubernetes and Nomad for a small platform team running 20 internal services. Give a concise recommendation with tradeoffs."
      }
    ],
    "tools": [
      {
        "type": "model_synthesis",
        "analysis_models": [
          "openai-gpt-5.5",
          "deepseek-v4-pro"
        ],
        "max_tool_calls": 8,
        "max_tokens": 16000
      }
    ],
    "tool_choice": "required",
    "max_tokens": 16000,
    "stream": false
  }'

Responses API

The following example sends a Responses API request with the model synthesis tool enabled. Set input instead of messages and use max_output_tokens at the top level. The model synthesis tool object always uses max_tokens on all endpoints.

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.responses.create(
    model="openai-gpt-5.2",
    input=(
        "What are the tradeoffs between RAG and fine-tuning "
        "for domain-specific QA?"
    ),
    max_output_tokens=4096,
    tools=[
        {
            "type": "model_synthesis",
            "model": "openai-gpt-5.2",
            "analysis_models": [
                "anthropic-claude-opus-4.6",
                "google-gemini-3.1-pro",
            ],
            "max_tool_calls": 5,
            "max_tokens": 2048,
            "reasoning_effort": "high",
        }
    ],
    tool_choice={"type": "function", "name": "model_synthesis"},
    stream=False,
)

print(resp)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const resp = await client.responses.create({
    model: "openai-gpt-5.2",
    input:
        "What are the tradeoffs between RAG and fine-tuning " +
        "for domain-specific QA?",
    max_output_tokens: 4096,
    tools: [
        {
            type: "model_synthesis",
            model: "openai-gpt-5.2",
            analysis_models: [
                "anthropic-claude-opus-4.6",
                "google-gemini-3.1-pro",
            ],
            max_tool_calls: 5,
            max_tokens: 2048,
            reasoning_effort: "high",
        },
    ],
    tool_choice: { type: "function", name: "model_synthesis" },
    stream: false,
});

console.log(resp);

curl -X POST https://inference.do-ai.run/v1/responses \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai-gpt-5.2",
    "input": "What are the tradeoffs between RAG and fine-tuning for domain-specific QA?",
    "max_output_tokens": 4096,
    "tools": [
      {
        "type": "model_synthesis",
        "model": "openai-gpt-5.2",
        "analysis_models": [
          "anthropic-claude-opus-4.6",
          "google-gemini-3.1-pro"
        ],
        "max_tool_calls": 5,
        "max_tokens": 2048,
        "reasoning_effort": "high"
      }
    ],
    "tool_choice": { "type": "function", "name": "model_synthesis" },
    "stream": false
  }'

Messages API

The following example sends a Messages API request with the model synthesis tool enabled. Set max_tokens at the top level. The model synthesis tool object always uses max_tokens on all endpoints.

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.messages.create(
    model="anthropic-claude-opus-4.6",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": (
                "What are the tradeoffs between RAG and fine-tuning "
                "for domain-specific QA?"
            ),
        },
    ],
    tools=[
        {
            "type": "model_synthesis",
            "model": "anthropic-claude-opus-4.6",
            "analysis_models": [
                "openai-gpt-5.2",
                "google-gemini-3.1-pro",
            ],
            "max_tool_calls": 5,
            "max_tokens": 2048,
            "reasoning_effort": "high",
        }
    ],
    tool_choice={"type": "tool", "name": "model_synthesis"},
)

print(resp)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const resp = await client.messages.create({
    model: "anthropic-claude-opus-4.6",
    max_tokens: 4096,
    messages: [
        {
            role: "user",
            content:
                "What are the tradeoffs between RAG and fine-tuning " +
                "for domain-specific QA?",
        },
    ],
    tools: [
        {
            type: "model_synthesis",
            model: "anthropic-claude-opus-4.6",
            analysis_models: ["openai-gpt-5.2", "google-gemini-3.1-pro"],
            max_tool_calls: 5,
            max_tokens: 2048,
            reasoning_effort: "high",
        },
    ],
    tool_choice: { type: "tool", name: "model_synthesis" },
});

console.log(resp);

curl -X POST https://inference.do-ai.run/v1/messages \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic-claude-opus-4.6",
    "max_tokens": 4096,
    "messages": [
      {
        "role": "user",
        "content": "What are the tradeoffs between RAG and fine-tuning for domain-specific QA?"
      }
    ],
    "tools": [
      {
        "type": "model_synthesis",
        "model": "anthropic-claude-opus-4.6",
        "analysis_models": [
          "openai-gpt-5.2",
          "google-gemini-3.1-pro"
        ],
        "max_tool_calls": 5,
        "max_tokens": 2048,
        "reasoning_effort": "high"
      }
    ],
    "tool_choice": { "type": "tool", "name": "model_synthesis" }
  }'

Set tool_choice to required on the Chat Completions API to run the model synthesis tool on every request. On the Responses API, use {"type": "function", "name": "model_synthesis"}. On the Messages API, use {"type": "tool", "name": "model_synthesis"} or any to require the model synthesis tool. Set tool_choice to auto on any endpoint to let the top-level model invoke the model synthesis tool only when the prompt benefits from multiple perspectives. Simple prompts such as greetings usually complete without invoking the model synthesis tool.

Streaming

Panel model calls are always non-streaming. When you set stream to true at the top level, only the outer model’s final synthesis streams back to your application. stream_options.include_usage behaves as it does for other inference requests.

Latency and Timeouts

The model synthesis tool is a long-running call. Plan for long client read timeouts in your application.

Research-style model synthesis tool requests typically take 3 to 6 minutes end-to-end while panel models run in parallel, the judge compares results, and the outer model synthesizes the final answer. Web-heavy prompts, more or larger panel models, or higher reasoning_effort can increase latency to as much as 8 to 10 minutes.

The main latency settings are the number and size of panel models, web search volume (max_tool_calls), and reasoning_effort.

Panel sub-calls time out after 12 minutes. Judge sub-calls time out after 8 minutes. Sub-call timeouts are not retried. The inference gateway terminates long requests at 20 minutes (1200 seconds). Set your client read timeout to at least 20 minutes. Treat an HTTP 504 from the gateway as retryable, not a hard failure.

Usage and Cost

Panel models run concurrently, which is faster than calling each model sequentially. The model synthesis tool still waits for panel, judge, and tool work before the outer model writes the final answer, so a model synthesis tool request generally costs more and takes longer than a single-model completion.

One model synthesis tool API request is not one model call. Usage reflects token consumption and tool calls for every panel model, the judge, the outer model, and any web search or web fetch steps those models perform. The model synthesis tool does not add a separate charge. You are billed at the existing per-model token rates and web tool rates.

The response includes per-model usage throughout the request. The final usage message aggregates token counts across all participating models. To inspect individual model consumption, review usage on each model response in the stream or completion payload, not only the final aggregate.

Failure and Degradation

The model synthesis tool returns HTTP 200 for most partial failures and lets the outer model produce a final answer when possible. The result depends on which stage fails:

• If some panel models fail or return empty output, the model synthesis tool continues. The summary it sends to the outer model includes failure details. The outer model may mention gaps only when they affect the final answer.
• If all panel models fail, the summary reports that the model synthesis tool failed. The outer model answers from its own knowledge. The response may include a failure_reason such as all_panels_failed, rate_limited, or insufficient_credits.
• If the judge fails or returns bad or truncated JSON, panel responses are retained, but structured analysis is omitted. The summary notes that judge comparison is unavailable.
• If web tools are disabled with max_tool_calls: 0 but a model emits tool calls, the inner model call fails as empty content and follows the partial or total failure paths above. Setting max_tool_calls to 0 also disables web tools on the outer synthesis step.

Failed panel or judge models may appear in a failed_models list when orchestration continues with other participants.

Use the Model Synthesis Tool with Other Server-Side Tools

You can include the model synthesis tool in the tools array with other server-side tools such as web_search in the same request. In one turn, the model synthesis tool and other built-in tools can all execute. Results from other tools are included in the summary the model synthesis tool sends to the outer model.

The model synthesis tool runs at most once per turn. Duplicate model synthesis tool entries in the same request are ignored after the first invocation. Nested model synthesis tool calls are blocked.

After the model synthesis tool executes, it is unavailable for the rest of that turn. Other tools remain available. On the Chat Completions and Responses APIs, tool_choice set to required or a named function choice is changed to auto after the first built-in tool executes so the follow-up turn is not forced to call another tool. On the Messages API, any or a specific tool choice is changed to auto after a built-in call.

Limitations and Review

The model synthesis tool does not guarantee a correct answer. Several models can repeat the same outdated fact, rely on the same weak source, or share a reasoning error. Agreement among panel models is one signal, but not proof of accuracy.

The model synthesis tool does not replace source verification or human review for important decisions. Review outputs and supporting evidence before acting on them.

Data Governance

Model synthesis tool requests are not stored by DigitalOcean. Retention follows the same policies as the underlying model calls. A model synthesis tool request is evaluated by every model on the panel, so model selection is a data-governance decision. Confirm that your prompt and context are appropriate for each provider in the panel. For provider terms, see Third-Party AI Models.

Retrieve Knowledge Base

Knowledge base retrieval lets the model query your private data sources during inference using retrieval-augmented generation (RAG). You add the knowledge_base_retrieval tool to your API request and the inference API handles retrieval and incorporates the results into the model’s response automatically.

To use knowledge base retrieval, send a POST request with your knowledge base ID. You can find the ID in the DigitalOcean Control Panel or by querying the API. For example, use the Chat Completions API with knowledge base retrieval:

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.chat.completions.create(
    model="openai-gpt-4o",
    messages=[
        {"role": "user", "content": "What are some features of DigitalOcean Inference?"},
    ],
    tools=[
        {
            "type": "knowledge_base_retrieval",
            "knowledge_base_id": "<your-knowledge-base-id>",
        }
    ],
    tool_choice="auto",
    stream=False,
    max_tokens=1024,
)

print(resp.choices[0].message.content)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const completion = await client.chat.completions.create({
    model: "openai-gpt-4o",
    messages: [
        { role: "user", content: "What are some features of DigitalOcean Inference?" },
    ],
    tools: [
        {
            type: "knowledge_base_retrieval",
            knowledge_base_id: "<your-knowledge-base-id>",
        },
    ],
    tool_choice: "auto",
    stream: false,
    max_tokens: 1024,
});

console.log(completion.choices[0].message.content);

curl -X POST https://inference.do-ai.run/v1/chat/completions \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai-gpt-4o",
    "messages": [
      {
        "role": "user",
        "content": "What are some features of DigitalOcean Inference?"
      }
    ],
    "tools": [
      {
        "type": "knowledge_base_retrieval",
        "knowledge_base_id": "<your-knowledge-base-id>"
      }
    ],
    "tool_choice": "auto",
    "stream": false,
    "max_tokens": 1024
  }'

For the full set of parameters, see the Serverless Inference API reference. The response looks like the following:

{
    "choices": [
        {
            "finish_reason": "stop",
            "index": 0,
            "logprobs": null,
            "message": {
                "annotations": [
                    {
                        "type": "tool_use",
                        "tool_use": {
                            "name": "knowledge_base_retrieval",
                            "call_id": "call_y6aBCI2IrnS8ZgPR6DKjXl9T",
                            "arguments": "{\"query\":\"features of DigitalOcean Inference\"}",
                            "status": "completed",
                            "output": "{\"knowledge_base_id\":\"e7651dee-da73-11ef-bf8f-4e013e2dxxxx\",\"query\":\"features of DigitalOcean Inference\",\"results\":[{\"metadata\":{\"chunk_category\":\"CompositeElement\",\"ingested_timestamp\":\"2026-05-11T18:15:46.532085+00:00\",\"item_name\":\"https://docs.digitalocean.com/\",\"page_number\":null},\"text_content\":\"### 1 May 2026 [ ](https://docs.digitalocean.com/#1-may-2026) * The following DeepSeek model is now available on DigitalOcean Inference for [serverless inference](https://docs.digitalocean.com/products/inference/how-to/use-serverless-inference/), [Agent Development Kit](https://docs.digitalocean.com/products/inference/how-to/build-agents-using-adk/) and [agents](https://docs.digitalocean.com/products/inference/how-to/create-agents/): For more information, see the [Available Models page](https://docs.digitalocean.com/products/inference/details/models/).\"},{\"metadata\":{\"chunk_category\":\"CompositeElement\",\"ingested_timestamp\":\"2026-05-11T18:15:46.532085+00:00\",\"item_name\":\"https://docs.digitalocean.com/\",\"page_number\":null},\"text_content\":\"### 5 May 2026 [ ](https://docs.digitalocean.com/#5-may-2026) ....\"}],\"total_results\":3}"
                        }
                    }
                ],
                "content": "DigitalOcean Inference includes several features designed to support serverless inference and facilitate the development and deployment of AI models and agents. ...",
                "reasoning_content": null,
                "refusal": null,
                "role": "assistant"
            }
        }
    ],
    ...
    }
}

Use the Responses API with knowledge base retrieval:

curl -X POST https://inference.do-ai.run/v1/responses \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "input": "What is actions infrastructure? Answer using the knowledge base.",
    "tools": [
      {
        "type": "knowledge_base_retrieval",
        "knowledge_base_id": "09d65da1-5225-11f1-b074-4e013e2dxxxx"
      }
    ],
    "stream": false,
    "max_output_tokens": 1024
  }'

The response looks similar to the following:

{
  "background": false,
  "completed_at": 0,
  "created_at": 1779045957,
  "error": {
    "code": "",
    "message": ""
  },
  "frequency_penalty": 0,
  "id": "resp_b999e07cebb3dd7a",
  "incomplete_details": {
    "reason": ""
  },
  "instructions": {
    "OfInputItemList": null,
    "OfString": ""
  },
  "max_output_tokens": 1024,
  "max_tool_calls": 0,
  "metadata": null,
  "model": "deepseek-v4-pro",
  "object": "response",
  "output": [
    {
      "arguments": "{\"query\": \"What is actions infrastructure?\"}",
      "call_id": "chatcmpl-tool-8e9ce86361b0fe64",
      "name": "knowledge_base_retrieval",
      "status": "completed",
      "type": "function_call"
    },
    {
      "call_id": "chatcmpl-tool-8e9ce86361b0fe64",
      "output": "{\"knowledge_base_id\":\"09d65da1-5225-11f1-b074-4e013e2dxxxx\",\"query\":\"What is actions infrastructure?\",\"results\":[{\"metadata\":{\"chunk_category\":\"CompositeElement\",\"ingested_timestamp\":\"2026-05-17T19:23:20.695776+00:00\",\"item_name\":\"example-document.pdf\",\"page_number\":45},\"text_content\":\"Example content retrieved from your knowledge base.\"}],\"total_results\":1}",
      "status": "completed",
      "type": "function_call_output"
    }
  ]
}

Use Model Context Protocol (MCP)

MCP servers expose tools that the model can call, such as fetching account data, managing schedules, or interacting with third-party APIs. The MCP built-in tool connects the model to remote Model Context Protocol (MCP) servers and orchestrates calls to them.

Connect to an Authenticated MCP Server

You can connect to authenticated MCP servers using bearer token authentication. The following example sends a Chat Completions request that connects to the DigitalOcean Accounts MCP server. Replace $DIGITALOCEAN_API_TOKEN with a valid DigitalOcean personal access token.

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.chat.completions.create(
    model="openai-gpt-4o",
    messages=[
        {"role": "user", "content": "Fetch my DigitalOcean account information and summarize it in 2 bullets."},
    ],
    tools=[
        {
            "type": "mcp",
            "server_label": "digitalocean",
            "server_url": "https://accounts.mcp.digitalocean.com/mcp",
            "authorization": f"Bearer {os.environ.get('DIGITALOCEAN_API_TOKEN')}",
            "allowed_tools": ["account-get-information"],
        }
    ],
    tool_choice="required",
    stream=False,
    max_tokens=512,
)

print(resp.choices[0].message.content)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const completion = await client.chat.completions.create({
    model: "openai-gpt-4o",
    messages: [
        { role: "user", content: "Fetch my DigitalOcean account information and summarize it in 2 bullets." },
    ],
    tools: [
        {
            type: "mcp",
            server_label: "digitalocean",
            server_url: "https://accounts.mcp.digitalocean.com/mcp",
            authorization: `Bearer ${process.env.DIGITALOCEAN_API_TOKEN}`,
            allowed_tools: ["account-get-information"],
        },
    ],
    tool_choice: "required",
    stream: false,
    max_tokens: 512,
});

console.log(completion.choices[0].message.content);

curl -X POST https://inference.do-ai.run/v1/chat/completions \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai-gpt-4o",
    "messages": [
      {
        "role": "user",
        "content": "Fetch my DigitalOcean account information and summarize it in 2 bullets."
      }
    ],
    "tools": [
      {
        "type": "mcp",
        "server_label": "digitalocean",
        "server_url": "https://accounts.mcp.digitalocean.com/mcp",
        "authorization": "Bearer $DIGITALOCEAN_API_TOKEN",
        "allowed_tools": ["account-get-information"]
      }
    ],
    "tool_choice": "required",
    "stream": false,
    "max_tokens": 512
  }'

The allowed_tools array restricts which tools from the MCP server the model can call. In this example, only the account-get-information tool is available. When omitted, the model can use any tool the server exposes. For the full set of MCP tool parameters, see the Serverless Inference API reference. The response looks like the following:

{
    "choices": [
        {
            "finish_reason": "stop",
            "index": 0,
            "logprobs": null,
            "message": {
                "annotations": [
                    {
                        "type": "tool_use",
                        "tool_use": {
                            "name": "digitalocean__account-get-information",
                            "call_id": "call_xasb9Xk1HAfT564P3bteZZTT",
                            "arguments": "{}",
                            "status": "completed",
                            "output": "{\n  \"droplet_limit\": 100,\n  \"floating_ip_limit\": 75,\n  \"reserved_ip_limit\": 75,\n  \"volume_limit\": 5000,\n  \"email\": \"[email protected]\",\n  \"name\": \"dev-sammy\",\n  \"uuid\": \"de55ee97-21ab-452d-aaf0-d4046480xxxx\",\n  \"email_verified\": true,\n  \"status\": \"active\",\n  \"team\": {\n    \"name\": \"My Team\",\n    \"uuid\": \"de55ee97-21ab-452d-aaf0-d4046480xxxx\"\n  }\n}"
                        }
                    }
                ],
                "content": "- Your account (\"dev-sammy\") is active with email \"[email protected]\", which is verified. You are part of \"My Team\" with a UUID of \"de55ee97-21ab-452d-aaf0-d4046480xxxx\".\n- You have a resource allocation limit of 100 droplets, 75 floating IPs, 75 reserved IPs, and 5000 volumes.",
                "reasoning_content": null,
                "refusal": null,
                "role": "assistant"
            }
        }
    ],
....    }
}

Connect to an Unauthenticated MCP Server

You can also connect to public MCP servers that do not require authentication. The following example sends a Responses API request:

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.responses.create(
    model="openai-gpt-4o",
    input="Create a scheduling poll called Team Lunch with two time options for tomorrow at noon and the day after at noon.",
    tools=[
        {
            "type": "mcp",
            "server_label": "timergy",
            "server_url": "https://api.timergy.com/mcp",
        }
    ],
    tool_choice="required",
    stream=False,
    max_output_tokens=512,
)

print(resp)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const resp = await client.responses.create({
    model: "openai-gpt-4o",
    input: "Create a scheduling poll called Team Lunch with two time options for tomorrow at noon and the day after at noon.",
    tools: [
        {
            type: "mcp",
            server_label: "timergy",
            server_url: "https://api.timergy.com/mcp",
        },
    ],
    tool_choice: "required",
    stream: false,
    max_output_tokens: 512,
});

console.log(resp);

curl -X POST https://inference.do-ai.run/v1/responses \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai-gpt-4o",
    "input": "Create a scheduling poll called Team Lunch with two time options for tomorrow at noon and the day after at noon.",
    "tools": [
      {
        "type": "mcp",
        "server_label": "timergy",
        "server_url": "https://api.timergy.com/mcp"
      }
    ],
    "tool_choice": "required",
    "stream": false,
    "max_output_tokens": 512
  }'

The response looks like the following:

{
...
  "model": "openai-gpt-4o",
  "object": "response",
  "output": [
    {
      "arguments": "{\"autoFinalize\":false,\"creatorName\":\"Assistant for Team\",\"deadline\":\"2026-04-08T12:00:00-05:00\",\"description\":\"Scheduling poll for a team lunch\",\"invitees\":[],\"location\":\"Office Cafeteria\",\"options\":[{\"end\":\"2026-04-10T13:00:00-05:00\",\"start\":\"2026-04-10T12:00:00-05:00\"},{\"end\":\"2026-04-11T13:00:00-05:00\",\"start\":\"2026-04-11T12:00:00-05:00\"}],\"title\":\"Team Lunch\"}",
      "call_id": "call_uallF71f2THNYsEvZUubSUhQ",
      "name": "timergy__create_poll",
      "status": "completed",
      "type": "function_call"
    },
    {
      "call_id": "call_uallF71f2THNYsEvZUubSUhQ",
      "output": "{\n  \"pollId\": \"fdc8110b-274d-45b4-b791-0149f6cfc4bc\",\n  \"title\": \"Team Lunch\",\n  \"url\": \"https://timergy.com/en/polls/fdc8110b-274d-45b4-b791-0149f6cfc4bc\",\n  \"passphrase\": \"horse-sword-thumb\",\n  \"options\": [\n    {\n      \"id\": \"c8879755-9136-497d-aedc-81b50fafbb13\",\n      \"start\": \"2026-04-10T17:00:00.000Z\",\n      \"end\": \"2026-04-10T18:00:00.000Z\",\n      \"label\": null\n    },\n    {\n      \"id\": \"58c474c6-12b4-42d5-a96e-c6c977d8a3b2\",\n      \"start\": \"2026-04-11T17:00:00.000Z\",\n      \"end\": \"2026-04-11T18:00:00.000Z\",\n      \"label\": null\n    }\n  ],\n  \"expiresAt\": \"2026-04-21T18:00:00.000Z\",\n  \"autoFinalize\": false,\n  \"inviteesSent\": 0,\n  \"note\": \"Share the URL with participants. The passphrase is saved for finalization. Assistant for Team's \\\"yes\\\" votes have been auto-submitted.\"\n}",
      "status": "completed",
      "type": "function_call_output"
    },
    {
      "content": [
        {
          "annotations": [],
          "logprobs": [],
          "text": "The scheduling poll \"Team Lunch\" has been created. You can share the following URL with participants to vote:\n\n**Poll URL:** [Team Lunch Poll](https://timergy.com/en/polls/fdc8110b-274d-45b4-b791-0149f6cfc4bc)\n\nFor admin access and to finalize the poll, you can use the passphrase:\n\n**Passphrase:** `horse-sword-thumb`\n\nThe poll includes two time slot options:\n- April 10, 2026, from 12:00 PM to 1:00 PM (local time)\n- April 11, 2026, from 12:00 PM to 1:00 PM (local time)",
          "type": "output_text"
        }
      ],
...
  "tool_choice": "auto",
  "tools": [
    {
      "type": "mcp",
      "server_label": "timergy",
      "server_url": "https://api.timergy.com/mcp"
    }
  ],
...
  }
}

Supported Anthropic and OpenAI Tools

Tool Search

Tool search enables searching and loading of tools on demand in the model’s context in agentic workflows. This allows you to avoid loading all tool definitions up front and can reduce overall token usage and cost. Use the passthrough tool search tool on the Messages API for Anthropic models and the Responses API for OpenAI models.

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.messages.create(
    model="anthropic-claude-opus-4.8",
    max_tokens=2048,
    messages=[
        {"role": "user", "content": "What is the weather in zip code 94107?"},
    ],
    tools=[
        {
            "type": "tool_search_tool_regex_20251119",
            "name": "tool_search_tool_regex",
        },
        {
            "name": "get_weather_by_zip",
            "description": "Return current weather conditions for a US zip code.",
            "input_schema": {
                "type": "object",
                "properties": {
                    "zip_code": {"type": "string"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
                },
                "required": ["zip_code"],
            },
            "defer_loading": True,
        },
        {
            "name": "search_files",
            "description": "Search through files in the workspace",
            "input_schema": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "file_types": {"type": "array", "items": {"type": "string"}},
                },
                "required": ["query"],
            },
            "defer_loading": True,
        },
    ],
)

print(resp)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const resp = await client.messages.create({
    model: "anthropic-claude-opus-4.8",
    max_tokens: 2048,
    messages: [
        { role: "user", content: "What is the weather in zip code 94107?" },
    ],
    tools: [
        {
            type: "tool_search_tool_regex_20251119",
            name: "tool_search_tool_regex",
        },
        {
            name: "get_weather_by_zip",
            description: "Return current weather conditions for a US zip code.",
            input_schema: {
                type: "object",
                properties: {
                    zip_code: { type: "string" },
                    unit: { type: "string", enum: ["celsius", "fahrenheit"] },
                },
                required: ["zip_code"],
            },
            defer_loading: true,
        },
        {
            name: "search_files",
            description: "Search through files in the workspace",
            input_schema: {
                type: "object",
                properties: {
                    query: { type: "string" },
                    file_types: { type: "array", items: { type: "string" } },
                },
                required: ["query"],
            },
            defer_loading: true,
        },
    ],
});

console.log(resp);

curl -X POST https://inference.do-ai.run/v1/messages \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic-claude-opus-4.8",
    "max_tokens": 2048,
    "messages": [
      {
        "role": "user",
        "content": "What is the weather in zip code 94107?"
      }
    ],
    "tools": [
      {
        "type": "tool_search_tool_regex_20251119",
        "name": "tool_search_tool_regex"
      },
      {
        "name": "get_weather_by_zip",
        "description": "Return current weather conditions for a US zip code.",
        "input_schema": {
          "type": "object",
          "properties": {
            "zip_code": {"type": "string"},
            "unit": {
              "type": "string",
              "enum": ["celsius", "fahrenheit"]
            }
          },
          "required": ["zip_code"]
        },
        "defer_loading": true
      },
      {
        "name": "search_files",
        "description": "Search through files in the workspace",
        "input_schema": {
          "type": "object",
          "properties": {
            "query": {"type": "string"},
            "file_types": {
              "type": "array",
              "items": {"type": "string"}
            }
          },
          "required": ["query"]
        },
        "defer_loading": true
      }
    ]
  }'

{
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "I'll search for tools to help with the weather information."
    },
    {
      "type": "server_tool_use",
      "id": "srvtoolu_01ABC123",
      "name": "tool_search_tool_regex",
      "input": {
        "query": "weather"
      }
    },
    {
      "type": "tool_search_tool_result",
      "tool_use_id": "srvtoolu_01ABC123",
      "content": {
        "type": "tool_search_tool_search_result",
        "tool_references": [{ "type": "tool_reference", "tool_name": "get_weather_by_zip" }]
      }
    },
    {
      "type": "text",
      "text": "I found a weather tool. Let me get the weather for zip code 94107."
    },
    {
      "type": "tool_use",
      "id": "toolu_01XYZ789",
      "name": "get_weather_by_zip",
      "input": { "zip_code": "94107", "unit": "fahrenheit" }
    }
  ],
  "stop_reason": "tool_use"
}

{
  "usage": {
    "input_tokens": 1024,
    "output_tokens": 256,
    "server_tool_use": {
      "tool_search_requests": 2
    }
  }
}

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.responses.create(
    model="openai-gpt-5.5",
    input="Compare the current weather in zip code 94107 and 10001.",
    tools=[
        {
            "type": "namespace",
            "name": "weather",
            "description": "Weather lookup tools for US zip codes.",
            "tools": [
                {
                    "type": "function",
                    "name": "get_weather_by_zip",
                    "description": "Return current weather conditions for a US zip code.",
                    "defer_loading": True,
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "zip_code": {"type": "string"},
                        },
                        "required": ["zip_code"],
                        "additionalProperties": False,
                    },
                }
            ],
        },
        {"type": "tool_search"},
    ],
    parallel_tool_calls=False,
)

print(resp)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const resp = await client.responses.create({
    model: "openai-gpt-5.5",
    input: "Compare the current weather in zip code 94107 and 10001.",
    tools: [
        {
            type: "namespace",
            name: "weather",
            description: "Weather lookup tools for US zip codes.",
            tools: [
                {
                    type: "function",
                    name: "get_weather_by_zip",
                    description: "Return current weather conditions for a US zip code.",
                    defer_loading: true,
                    parameters: {
                        type: "object",
                        properties: {
                            zip_code: { type: "string" },
                        },
                        required: ["zip_code"],
                        additionalProperties: false,
                    },
                },
            ],
        },
        { type: "tool_search" },
    ],
    parallel_tool_calls: false,
});

console.log(resp);

curl -X POST https://inference.do-ai.run/v1/responses \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai-gpt-5.5",
    "input": "Compare the current weather in zip code 94107 and 10001.",
    "tools": [
      {
        "type": "namespace",
        "name": "weather",
        "description": "Weather lookup tools for US zip codes.",
        "tools": [
          {
            "type": "function",
            "name": "get_weather_by_zip",
            "description": "Return current weather conditions for a US zip code.",
            "defer_loading": true,
            "parameters": {
              "type": "object",
              "properties": {
                "zip_code": { "type": "string" }
              },
              "required": ["zip_code"],
              "additionalProperties": false
            }
          }
        ]
      },
      {
        "type": "tool_search"
      }
    ],
    "parallel_tool_calls": false
  }'

[
  {
    "type": "tool_search_call",
    "execution": "server",
    "call_id": null,
    "status": "completed",
    "arguments": {
      "paths": ["weather"]
    }
  },
  {
    "type": "tool_search_output",
    "execution": "server",
    "call_id": null,
    "status": "completed",
    "tools": [
  ....
  },
  {
    "type": "function_call",
    "name": "get_weather_by_zip",
    "namespace": "weather",
    "call_id": "call_abc123",
    "arguments": "{\"zip_code\":\"94107\"}"
  }
]

Computer Use

With the computer use tool, you can interact with computer environments for autonomous desktop interaction such as screenshots, mouse and keyboard control, and desktop automation. You can use the computer use tool in combination with other tools such as bash and text editor for more comprehensive automation workflows.

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.messages.create(
    model="anthropic-claude-opus-4.8",
    max_tokens=1024,
    tools=[
        {
            "type": "computer_20251124",
            "name": "computer",
            "display_width_px": 1024,
            "display_height_px": 768,
            "display_number": 1,
        }
    ],
    messages=[
        {"role": "user", "content": "Save a picture of a cat to my desktop."}
    ],
    headers={"anthropic-beta": "computer-use-2025-11-24"},
)

print(resp)

curl -X POST https://inference.do-ai.run/v1/messages \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -H "anthropic-beta: computer-use-2025-11-24" \
  -d '{
    "model": "anthropic-claude-opus-4.8",
    "max_tokens": 1024,
    "tools": [
      {
        "type": "computer_20251124",
        "name": "computer",
        "display_width_px": 1024,
        "display_height_px": 768,
        "display_number": 1
      }
    ],
    "messages": [
      {
        "role": "user",
        "content": "Save a picture of a cat to my desktop."
      }
    ]
  }'

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.responses.create(
    model="openai-gpt-5.5",
    input="Check whether the Filters panel is open. If it is not open, click Show filters. Then type penguin in the search box. Use the computer tool for UI interaction.",
    tools=[
        {"type": "computer"}
    ],
)

print(resp)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const resp = await client.responses.create({
    model: "openai-gpt-5.5",
    input: "Check whether the Filters panel is open. If it is not open, click Show filters. Then type penguin in the search box. Use the computer tool for UI interaction.",
    tools: [
        { type: "computer" },
    ],
});

console.log(resp);

curl -X POST https://inference.do-ai.run/v1/responses \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai-gpt-5.5",
    "input": "Check whether the Filters panel is open. If it is not open, click Show filters. Then type penguin in the search box. Use the computer tool for UI interaction.",
    "tools": [
      {
        "type": "computer"
      }
    ]
  }'

Local Shell/Bash

Use the local shell tool to execute shell commands in a persistent session, allowing system operations, script execution, access to environment variables, and command-line automation. Use the bash tool with the Messages API for Anthropic models and the local shell tool with the Responses API for OpenAI models:

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.messages.create(
    model="anthropic-claude-opus-4.8",
    max_tokens=1024,
    tools=[
        {"type": "bash_20250124", "name": "bash"}
    ],
    messages=[
        {"role": "user", "content": "List all Python files in the current directory."}
    ],
)

print(resp)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const resp = await client.messages.create({
    model: "anthropic-claude-opus-4.8",
    max_tokens: 1024,
    tools: [
        { type: "bash_20250124", name: "bash" },
    ],
    messages: [
        { role: "user", content: "List all Python files in the current directory." },
    ],
});

console.log(resp);

curl -X POST https://inference.do-ai.run/v1/messages \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic-claude-opus-4.8",
    "max_tokens": 1024,
    "tools": [
      {
        "type": "bash_20250124",
        "name": "bash"
      }
    ],
    "messages": [
      {
        "role": "user",
        "content": "List all Python files in the current directory."
      }
    ]
  }'

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.responses.create(
    model="openai-gpt-5.5",
    instructions="The local bash shell environment is on Linux.",
    input="List all Python files in the current directory.",
    tools=[
        {
            "type": "shell",
            "environment": {
                "type": "local",
            },
        }
    ],
)

print(resp)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const resp = await client.responses.create({
    model: "openai-gpt-5.5",
    instructions: "The local bash shell environment is on Linux.",
    input: "List all Python files in the current directory.",
    tools: [
        {
            type: "shell",
            environment: {
                type: "local",
            },
        },
    ],
});

console.log(resp);

curl -X POST https://inference.do-ai.run/v1/responses \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai-gpt-5.5",
    "instructions": "The local bash shell environment is on Linux.",
    "input": "List all Python files in the current directory.",
    "tools": [
      {
        "type": "shell",
        "environment": {
          "type": "local"
        }
      }
    ]
  }'

Web Fetch

(For Anthropic models) Using an Anthropic-schema web fetch tool, the model can retrieve the full content of specific web pages and PDF documents to augment its context with live web content. The model fetches and reads the URL within a single request instead of running a multi-step agent loop.

Provide the web fetch tool to the model using the Messages API. Use the web_fetch_20250910 tool type with the name web_fetch. Optionally set max_uses to cap the number of fetches per request and allowed_domains or blocked_domains to restrict which sites the model can fetch. The following example sends a Messages API request with the web fetch tool enabled:

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.messages.create(
    model="anthropic-claude-opus-4.8",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Please analyze the content at https://docs.digitalocean.com/products/inference/",
        }
    ],
    tools=[
        {
            "type": "web_fetch_20250910",
            "name": "web_fetch",
            "max_uses": 5,
        }
    ],
)

print(resp)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const resp = await client.messages.create({
    model: "anthropic-claude-opus-4.8",
    max_tokens: 1024,
    messages: [
        {
            role: "user",
            content: "Please analyze the content at https://docs.digitalocean.com/products/inference/",
        },
    ],
    tools: [
        {
            type: "web_fetch_20250910",
            name: "web_fetch",
            max_uses: 5,
        },
    ],
});

console.log(resp);

curl -X POST https://inference.do-ai.run/v1/messages \
  -H "Authorization: Bearer $MODEL_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic-claude-opus-4.8",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Please analyze the content at https://docs.digitalocean.com/products/inference/"
      }
    ],
    "tools": [
      {
        "type": "web_fetch_20250910",
        "name": "web_fetch",
        "max_uses": 5
      }
    ]
  }'

The response includes additional block types before the model’s final answer:

• server_tool_use: Indicates that the model is fetching a URL.
• web_fetch_tool_result: Contains the fetched page as a web_fetch_result object with a document block.

The response looks similar to the following:

{
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "I'll fetch the content from the page to analyze it."
    },
    {
      "type": "server_tool_use",
      "id": "srvtoolu_01234567890abcdef",
      "name": "web_fetch",
      "input": {
        "url": "https://docs.digitalocean.com/products/inference/"
      }
    },
    {
      "type": "web_fetch_tool_result",
      "tool_use_id": "srvtoolu_01234567890abcdef",
      "content": {
        "type": "web_fetch_result",
        "url": "https://docs.digitalocean.com/products/inference/",
        "content": {
          "type": "document",
          "source": {
            "type": "text",
            "media_type": "text/plain",
            "data": "DigitalOcean Inference provides serverless and dedicated access to foundation models..."
          },
          "title": "Inference | DigitalOcean Documentation"
        },
        "retrieved_at": "2025-08-25T10:30:00Z"
      }
    },
    {
      "type": "text",
      "text": "Based on the documentation, DigitalOcean Inference is a managed AI platform that provides access to foundation models through serverless and dedicated endpoints..."
    }
  ],
  ....
  }
}

For PDF documents, the document block uses base64-encoded data in source.data instead of plain text. Web fetch usage is tracked in usage.server_tool_use.web_fetch_requests.

The model decides when to fetch based on the prompt and the URLs available in the conversation. For security, the model can only fetch URLs that already appear in the conversation, such as a URL in a user message or one returned by a previous web search or web fetch result. The model then analyzes the fetched content and returns its answer, with optional citations when you set "citations": {"enabled": true} on the tool.

Because the model processes external web content, enable web fetch only in trusted environments or when handling non-sensitive data, and use max_uses, allowed_domains, and max_content_tokens to limit exposure and token usage. For the full parameter set, response handling, and security guidance, see the Anthropic web fetch tool documentation.

Code Editing

Both Anthropic and OpenAI models can edit files in your codebase. Anthropic models use the text editor tool with the Messages API, and OpenAI models use the apply patch tool with the Responses API:

import os
from pydo.inference import Client

client = Client(token=os.environ.get("MODEL_ACCESS_KEY"))

resp = client.messages.create(
    model="anthropic-claude-opus-4.8",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "There's a syntax error in my primes.py file. Can you help me fix it?",
        }
    ],
    tools=[
        {
            "type": "text_editor_20250728",
            "name": "str_replace_based_edit_tool",
            "max_characters": 10000,
        }
    ],
)

print(resp)

import { InferenceClient } from "@digitalocean/dots";

const client = new InferenceClient({
    apiKey: process.env.MODEL_ACCESS_KEY,
});

const resp = await client.messages.create({
    model: "anthropic-claude-opus-4.8",
    max_tokens: 1024,
    messages: [
        {
            role: "user",
            content: "There's a syntax error in my primes.py file. Can you help me fix it?",
        },
    ],
    tools: [
        {
            type: "text_editor_20250728",
            name: "str_replace_based_edit_tool",
            max_characters: 10000,
        },
    ],
});

console.log(resp);