Built-in Hosted Tools

1 · Hosted tools vs function tools essential

There are two kinds of tool, and the difference is who runs it. A function tool (the kind you built in the API chapter) is yours: the model emits a function_call, your code runs the real function, you feed the result back. A hosted tool is OpenAI's: you declare it in the tools list, and when the model decides to use it, OpenAI executes it server-side and folds the result back into the answer — your code never sees a tool-call loop at all.

The mental model: a function tool is a tool you bring to the job; a hosted tool is a tool already bolted to the workbench. For capabilities OpenAI has built and operates — searching the live web, searching a vector store of your files, running sandboxed Python — reaching for the hosted version means you don't build, host, or secure the plumbing. You just switch it on.

The common mistake is rebuilding something OpenAI already hosts — hand-rolling a web-search tool with a third-party API and a scraping loop when {"type": "web_search"} would have done it in one line. Conversely, don't force a bespoke capability (your pricing engine) into a hosted tool — that's what function tools and MCP are for (§4).

2 · Web search in one line essential

Give the model live web access by adding one entry to tools. When a question needs current information, the model searches, reads, and answers — citing what it found — with no loop on your side.

web_search.pyfrom openai import OpenAI
client = OpenAI()

resp = client.responses.create(
    model="gpt-5.5",
    tools=[{"type": "web_search"}],       # that's the whole setup
    input="What did OpenAI announce most recently?",
)
print(resp.output_text)                   # answer, grounded in live results

3 · File search over your documents intermediate

This is managed RAG. Instead of building the retrieval pipeline from Chapter 3 by hand — chunk, embed, store, search — you upload documents into a vector store and enable the hosted file_search tool pointed at it. The model retrieves relevant chunks and grounds its answer, with OpenAI running the retrieval.

file_search.pyfrom openai import OpenAI
client = OpenAI()

# assume you've created a vector store and added files to it;
# vs.id identifies it (see the Files API, oap3).
resp = client.responses.create(
    model="gpt-5.5",
    tools=[{
        "type": "file_search",
        "vector_store_ids": ["vs_abc123"],   # your indexed documents
    }],
    input="What is our refund window, per the policy docs?",
)
print(resp.output_text)                       # grounded in your files

4 · Hosted vs function vs MCP advanced

Three ways to give a model a capability, one decision. Hosted tool: OpenAI built and runs it (web/file search, code interpreter) — least work, least control, use when it fits your need out of the box. Function tool (ox2): your bespoke code, your execution loop — maximum control, use for logic unique to your app. MCP server (ox4): a reusable tool server, portable across clients — use for general capabilities you'll reuse or share.

5 · Tech-lead — cost, latency & trust tech-lead

Hosted tools are convenient but not free of consequence. They can carry per-call pricing on top of tokens, add latency (a web search is a round trip), and introduce external data into the model's context — which is a prompt-injection surface (a malicious page the web tool reads could carry instructions). The lead-level posture: enable a hosted tool when it genuinely beats building your own, budget for its per-call cost, and remember that content a tool pulls in is untrusted input — the same guardrail discipline from the safety chapters applies.

Knowledge check check yourself