AgentWeb

npx add-mcp 'https://api.agentweb.live/mcp'

Connect an agent to AgentWeb

AgentWeb provides business data, web search, research evidence, change watches and public recipes. See the generated LLM guide for the complete inventory. Availability and freshness depend on the source.

Hosted MCP

Prefer the hosted endpoint to discover the current tools without installing a local package. Get a key at https://agentweb.live/#signup and store it in your client's secret configuration. Do not put keys in source control or chat logs.

Use Streamable HTTP at https://api.agentweb.live/mcp, with X-API-Key: YOUR_API_KEY or Authorization: Bearer YOUR_API_KEY. Choose the instructions for your client below; configuration formats differ. Merge new entries into existing configuration instead of replacing the file.

Reconnect and call tools/list to confirm the actual catalog. Discovery is public; protected operations require a key. list_recipes discovers every public recipe, and execute_recipe runs one using its documented domain, recipe name and params. For example, news is news/search, holidays are holidays/list, Wikipedia is wikipedia.org/search, and products are amazon.com/search_products.

Local models

Your agent app connects to MCP; the model must support tool calling. You can keep inference on your machine, but AgentWeb tool requests leave it and may contact upstream sources. This is an online service, not an offline browsing setup.

Start with web_search, web_fetch, time_now, and weather_forecast. The OpenClaw and Hermes examples filter to these four tools. This is a conservative starting point, not a benchmarked optimum for every model. In other clients use their tool selection controls where available. Large tool catalogs can consume context and make tool selection harder for smaller models.

To enable all public recipes, add list_recipes and execute_recipe to your filter. Add business/research tools as needed using the live tool schemas, or remove the filter for the full catalog. Keep your usual tool approvals enabled.

OpenClaw

For current OpenClaw versions with native outbound MCP, add AGENTWEB_API_KEY=YOUR_API_KEY to ~/.openclaw/.env (or the Gateway process environment). Merge this into ~/.openclaw/openclaw.json:

{
  "mcp": {
    "servers": {
      "agentweb": {
        "url": "https://api.agentweb.live/mcp",
        "transport": "streamable-http",
        "headers": {
          "X-API-Key": "${AGENTWEB_API_KEY}"
        },
        "requestTimeoutMs": 65000,
        "toolFilter": {
          "include": [
            "web_search",
            "web_fetch",
            "time_now",
            "weather_forecast"
          ]
        }
      }
    }
  }
}

Alternatively use Settings → MCP, add a Streamable HTTP server, and set headers and tool filters in its scoped config editor. Do not enable OAuth for AgentWeb. Run openclaw mcp doctor agentweb --probe. Reload/restart the running Gateway if its tools do not refresh. Older installations without native MCP need an upgrade or their supported bridge; this is not a mcporter.json configuration. Official MCP setup · Secret environment.

Hermes

Set AGENTWEB_API_KEY=YOUR_API_KEY in the active profile's .env (default ~/.hermes/.env). Merge into that profile's config.yaml (default ~/.hermes/config.yaml):

mcp_servers:
  agentweb:
    url: https://api.agentweb.live/mcp
    headers:
      X-API-Key: "${AGENTWEB_API_KEY}"
    timeout: 65
    tools:
      include: [web_search, web_fetch, time_now, weather_forecast]
      resources: false
      prompts: false

Restart Hermes or use /reload-mcp, then verify a tool call. The key must be available to the profile running the agent, not just a different terminal. Official MCP guide · Config and secret references.

LM Studio and Cursor

In LM Studio (remote MCP supported from 0.3.17 build 10), open Program → Install → Edit mcp.json. Cursor uses the same mcpServers shape. Merge this entry and replace YOUR_API_KEY privately; do not commit a populated file:

{
  "mcpServers": {
    "agentweb": {
      "url": "https://api.agentweb.live/mcp",
      "headers": {
        "X-API-Key": "YOUR_API_KEY"
      }
    }
  }
}

Enable the server and tools for your chat. Use a model with tool calling support. This snippet exposes the full catalog; select only needed tools where your client supports it. Official LM Studio instructions.

Open WebUI and Ollama

In Open WebUI (0.6.31+), an administrator opens Settings → Admin → Integrations → External Tool Servers → Add Connection. Select MCP (Streamable HTTP), enter https://api.agentweb.live/mcp, select Bearer, and enter your AgentWeb key in the Key field. Save, assign access to the intended users, and enable the tools in chat. Users sharing the configured key also share its quota. See the official setup.

For Ollama, configure MCP in your agent app, such as Open WebUI, and select a tool-capable local model. If you write your own Ollama agent loop, pass a subset of the function schemas, execute returned calls through the dispatcher below, and return tool results to the model. Schemas alone do not execute tools. See Ollama tool calling.

Verify and troubleshoot

Ask: “Use AgentWeb's time_now tool with timezone Europe/Copenhagen and show the returned time.” Confirm an actual tool call and a result without isError. That public call checks connectivity. Next call web_search with q: "Python documentation", num: 1 and mode: "index" to check key authentication; zero matches is a valid result and does not prove upstream freshness.

• 401: check the key in the active profile or running service environment.
• No tools: confirm Streamable HTTP, the /mcp URL, enabled server, and filters.
• Tools listed but never used: check the model's tool support and the app's tool settings; try fewer tools and a direct single-tool request.
• Timeout: allow at least 65 seconds for web operations; inspect the actual error before retrying. A working clock call does not prove every source works.

For Claude, Windsurf, Cline and other clients, use their remote MCP setup with the endpoint and header above. Do not assume the LM Studio JSON is universal. If a client supports only stdio, use a bridge below.

Local stdio clients

The npm package is released separately from hosted MCP:

{"mcpServers":{"agentweb":{"command":"npx","args":["-y","agentweb-mcp"],"env":{"AGENTWEB_API_KEY":"YOUR_API_KEY"}}}}

Check the installed package's version and tools/list; do not infer parity from this guide or the hosted version. Older package releases have a smaller catalog.

For a Python bridge that discovers and calls hosted tools dynamically, download the Python MCP bridge, install mcp>=1.12,<2 and httpx, and configure your client to run that file with Python. Set AGENTWEB_API_KEY in its environment. The bridge preserves tool errors and content blocks instead of maintaining its own list of capabilities.

LangChain

Download the integration as agentweb_tools.py. Install langchain-core and requests. Set AGENTWEB_API_KEY, then load the current catalog explicitly at startup:

from agentweb_tools import load_agentweb_tools

tools = load_agentweb_tools()
# Bind these tools using your framework's agent/tool execution loop.

The existing named REST wrappers remain for compatibility but cover only a subset. The loader uses the hosted schemas and dispatches through MCP. A failed tool call raises ToolException; do not present it as a successful result.

Function-calling integrations

Download the generated schemas:

• OpenAI Chat Completions format
• Anthropic format
• Canonical MCP format

These are tool definitions, not an execution service. The OpenAI download uses nested type: function / function definitions; clients requiring a different format must adapt the schema envelope. All downloads use the canonical hosted tool names, including get_business (the old agentweb_get_business export was an integration-specific alias). Forward returned names and arguments to MCP:

import os
import requests


def call_agentweb(name, arguments):
    response = requests.post(
        "https://api.agentweb.live/mcp",
        headers={
            "X-API-Key": os.environ["AGENTWEB_API_KEY"],
            "Accept": "application/json, text/event-stream",
        },
        json={"jsonrpc": "2.0", "id": 1, "method": "tools/call",
              "params": {"name": name, "arguments": arguments}},
        timeout=65,
    )
    response.raise_for_status()
    message = response.json()  # AgentWeb's stateless endpoint returns JSON.
    if "error" in message:
        raise RuntimeError(message["error"])
    result = message["result"]
    if result.get("isError"):
        raise RuntimeError(result["content"])
    return result

For applications using separate users/workspaces, pass X-AgentWeb-User and X-AgentWeb-Workspace consistently on discovery and calls. Python stdio accepts AGENTWEB_USER and AGENTWEB_WORKSPACE environment variables; the LangChain loader accepts the same variables. Use the same idempotency_key only when retrying an identical research/watch creation request. Creating watches schedules future work and can consume quota; cancelling a watch changes its state.

REST clients

Base URL: https://api.agentweb.live/v1. Use live OpenAPI and capabilities for the current API. REST business search defaults to JSON; request format=text or Accept: text/markdown for prose. MCP business search/get defaults to prose.

GET /v1/recipes is public and includes auth and cache policy. Time tools are uncached. Most legacy recipes cache successful results for up to 30 minutes; travel/product recipes normally use 10 minutes. Research-backed fetch/research has its own evidence/freshness policy. Neither recipe discovery nor an HTTP 200 health response proves fresh ingestion or upstream availability.

Agent skills

Use the agent skill guide in your framework's supported skill location. Installing a file alone does not prove your agent loaded it: verify tool discovery and a public read such as time_now.