Groq Built-In Tools

Built-in (or server-side) tools are the easiest way to add agentic capabilities to your application. Unlike remote MCP where you connect to external servers, or local tool calling where you implement functions yourself, built-in tools require zero orchestration.

Just call the API, specify which tools you want to allow the model to use, and Groq's systems will handle the rest - tool execution, orchestration, and returning the final answer.

Built-in tools are not HIPAA Covered Cloud Services under Groq's Business Associate Addendum at this time. These tools are also not available currently for use with regional / sovereign endpoints.

How Built-In Tools Work

With built-in tools, execution happens entirely on Groq's servers. The model autonomously calls built-in tools (web search, code execution) and handles the entire agentic loop internally. You get one response with everything completed.

Your App → Makes request to Groq API with tools parameter
   ↓
Groq API → Makes request to LLM with built-in tool definitions from 
           the tools parameter
         ← Model returns tool_calls with built-in tool names (or, if no 
           tool calls are needed, returns final response)
   ↓
Groq API → Parses tool call arguments server-side
         → Makes request to built-in tool with tool call arguments
         ← Built-in tool returns results
   ↓
Groq API → Makes another request to LLM with tool results
         ← Model returns more tool_calls (returns to step 3), or 
           returns final response
   ↓
Your App

Which Models Support Built-In Tools

GPT-OSS Models

OpenAI's open-weight models support a subset of built-in tools:

Models:

openai/gpt-oss-120b
openai/gpt-oss-20b

Available Tools:

Tool	Identifier
Browser Search	`browser_search`
Code Execution	`code_interpreter`

Limitations:

Cannot use Visit Website or Wolfram Alpha

How to use GPT-OSS models:

from groq import Groq

client = Groq()

# Automatically uses tools when needed
response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[{
        "role": "user",
        "content": "What's the current population of Tokyo?"
    }]
)

# Or specify which tool to enable
response = client.chat.completions.create(
    model="openai/gpt-oss-120b",
    messages=[{
        "role": "user",
        "content": "Search for recent AI developments"
    }],
    tools=[{"type": "browser_search"}]
)

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

import Groq from "groq-sdk";

const client = new Groq();

// Automatically uses tools when needed
const response = await client.chat.completions.create({
  model: "openai/gpt-oss-120b",
  messages: [{
    role: "user",
    content: "What's the current population of Tokyo?"
  }]
});

// Or specify which tool to enable
const responseWithTool = await client.chat.completions.create({
  model: "openai/gpt-oss-120b",
  messages: [{
    role: "user",
    content: "Search for recent AI developments"
  }],
  tools: [{ type: "browser_search" }]
});

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

GPT-OSS models are ideal when you need a large context window (131K tokens) with basic tool capabilities.

Configuring Tools

Use the tools parameter with tool type objects. You can specify browser_search or code_interpreter.

# Single tool
tools=[{"type": "browser_search"}]

# Or multiple tools
tools=[{"type": "browser_search"}, {"type": "code_interpreter"}]

// Single tool
const tools = [{ type: "browser_search" }];

// Or multiple tools
const tools = [{ type: "browser_search" }, { type: "code_interpreter" }];