Tools API

Nexevo exposes a REST Tools API so any agent framework's SDK — LangChain, Anthropic, LlamaIndex, Gemini, or a custom client — can consume a safe subset of your workspace tools, in the wire format that framework already speaks.

Overview

The Tools API is the REST complement to the MCP server. Use MCP for MCP-native clients (Claude Desktop, Cursor); use the Tools API when you want plain REST JSON in a framework's own tool-calling format.

Endpoints

Three REST endpoints, all authed with a workspace API key:

GET /v1/tools?format=openai — list all available tool schemas in the requested wire format.
GET /v1/tools/{name}?format=anthropic — one tool's schema.
POST /v1/tools/{name}/invoke — execute a tool with arguments.

Authentication

Use the same workspace API key as the REST API, in the Authorization header. The key binds the call to one workspace — a client only ever sees that workspace's tools and data.

http

Authorization: Bearer sk-ws-...

What's exposed

Only a safe, read / compute-only subset of the agent toolset is available (identical to the MCP server's scope):

Web research — search, read a page, scrape, read a PDF/doc, OCR an image.
Open data — arXiv, SEC EDGAR, World Bank, OECD, market data, RSS.
Your workspace knowledge — rag_search over its long-term memory and uploaded knowledge.
Compute — a calculator, unit conversion, and other pure helpers.

Generation, email, browser, connectors, SQL, and destructive actions are not exposed — an external client can read and reason, but cannot spend or mutate.

Wire formats

The format query parameter selects how tool schemas are serialized. Pick the one your framework's SDK expects:

format	Schema field	Use with
`openai` (default)	`parameters`	OpenAI Chat Completions, LangChain
`openai_responses`	`parameters` (flat)	OpenAI Responses API
`anthropic`	`input_schema`	Anthropic Messages API
`mcp`	`inputSchema`	MCP-compatible clients
`gemini`	`parameters`	Google Gemini FunctionDeclarations

Listing tools

bash

curl https://nexevo.ai/v1/tools?format=anthropic \
  -H "Authorization: Bearer sk-ws-..."

json

{
  "tools": [
    {
      "name": "web_search",
      "description": "Search the public web ...",
      "input_schema": {
        "type": "object",
        "properties": { "query": { "type": "string" } },
        "required": ["query"]
      }
    }
  ],
  "format": "anthropic"
}

Invoking a tool

bash

curl -X POST https://nexevo.ai/v1/tools/web_search/invoke \
  -H "Authorization: Bearer sk-ws-..." \
  -H "Content-Type: application/json" \
  -d '{"arguments": {"query": "latest LLM benchmarks"}}'

json

{
  "content": "{\"count\": 5, \"results\": [...]}",
  "ok": true,
  "error_kind": "",
  "artifacts": []
}

Tool errors return ok: false with a error_kind (timeout / exception) and a human-readable content — never an HTTP error, so the calling agent can react.

Framework integration

The typical integration pattern: fetch the tool list once, pass it to your framework's tool-calling API, then route each tool call the model emits to POST /v1/tools/{name}/invoke.

Anthropic SDK

python

import anthropic, httpx

client = anthropic.Anthropic()
BASE = "https://nexevo.ai/v1"
HEADERS = {"Authorization": "Bearer sk-ws-..."}

# 1. fetch tools in Anthropic format
tools = httpx.get(f"{BASE}/tools", params={"format": "anthropic"}, headers=HEADERS).json()["tools"]

# 2. let Claude pick a tool, then execute it via Nexevo
msg = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "What's in my knowledge base about Q3?"}],
)
for block in msg.content:
    if block.type == "tool_use":
        r = httpx.post(f"{BASE}/tools/{block.name}/invoke",
                       headers=HEADERS, json={"arguments": block.input})
        print(r.json()["content"])

OpenAI / LangChain

python

import httpx
from langchain_core.tools import StructuredTool

BASE = "https://nexevo.ai/v1"
HEADERS = {"Authorization": "Bearer sk-ws-..."}

# fetch in OpenAI format, wrap each as a LangChain tool
raw = httpx.get(f"{BASE}/tools", params={"format": "openai"}, headers=HEADERS).json()["tools"]

def make_executor(name):
    def _run(**kwargs):
        r = httpx.post(f"{BASE}/tools/{name}/invoke", headers=HEADERS, json={"arguments": kwargs})
        return r.json()["content"]
    return _run

tools = [
    StructuredTool.from_function(
        func=make_executor(t["function"]["name"]),
        name=t["function"]["name"],
        description=t["function"]["description"],
        # args_schema can be derived from t["function"]["parameters"]
    )
    for t in raw
]