Bootstrap an integration from a catalog SDK with an agent
Install a generated SDK from the voxgig-sdk catalog, point the agent at its entity methods, and keep the glue off raw calls with a test, a gate, and one live check.
How-to › Section 9
Use AI to do the integration#
Coding agents, MCP clients, agent frameworks, structured output, evals, observability, cost and safety on the consuming side.
32 guides in 6 topics. Every guide compares its approaches and shows the output its commands printed.
- Write an integration with a coding agent 8
- Connect MCP clients to servers 4
- Build an agent that calls APIs 5
- Constrain model output to a schema 3
- Evaluate and observe agents 7
- Guard agents and add approvals 5
Write an integration with a coding agent 8 guides
Getting Claude Code, Cursor, Copilot, Codex CLI, Gemini CLI, Aider or Cline to write an API integration: prompting with the spec, feeding an SDK, a catalog SDK, a skill or the API's MCP server, stopping the agent inventing endpoints, reviewing generated code for missing retry and error handling, test-first loops, running the agent in a sandbox with a mock API, keeping generated files out of agent edits, and the experiments: measuring drift between two AI-written clients from one spec, comparing an AI-written client with generator output, and the hybrid workflow where an agent customizes a generated SDK without breaking regeneration.
Install an API skill and check a coding agent uses it
Install a vendor's published SKILL.md with its digest verified, lint the description the agent matches tasks against, and confirm the agent loads it.
Let a coding agent customize a generated SDK safely
Point the agent at the levers under .sdk/, never at the generated tree, and prove with doctor and a regeneration diff that only the intended files move.
Let a coding agent probe a live API through an MCP server
Give a coding agent a read-only probe of the real API while it writes the client, and check what came back against the document before the agent hard-codes it.
Measure drift between two AI-written clients
Compare two clients written from the same description and separate what one of them missed from what neither was told.
Run a coding agent headless in CI to keep a client current
Hand an upstream spec change to an agent in a read-only CI job, guard its patch, and open the pull request from a job that never holds the model key.
Stop a coding agent inventing endpoints not in the spec
Make an invented path a compile error, refuse the rest at a validation proxy, and review casts as well as tests, because an instruction on its own leaks.
Write a task prompt that gets an API integration done
Name the spec, the auth scheme, the language, the test command, and the done criteria in one task prompt, then check the agent's result against them yourself.
Connect MCP clients to servers 4 guides
Wiring an MCP server into Claude Desktop, Claude Code, ChatGPT, Cursor, Cline, VS Code and custom clients: stdio versus remote configuration, OAuth in client config, restricting which tools an agent may call, running several servers at once, composing servers behind one gateway (mcp-proxy), running a stdio server as a subprocess from a Python agent, health checks, debugging with MCP Inspector, and using catalog MCP servers, aontu-mcp and the tabnas mcp server as ready-made examples.
Authorize a remote MCP server with OAuth from a client
Walk an MCP client through a protected server's OAuth flow, keep its registration and tokens where you can find them, and recover when the server forgets it.
Connect a remote MCP server to Claude Desktop
Get a remote MCP server answering tool calls in Claude Desktop, as a custom connector or through a stdio bridge, and probe its transport before blaming the config.
Health check your MCP server connections
Probe an MCP server three ways, see which probe notices an upstream credential that expired, and set one reconnect and backoff policy for stdio and remote servers.
Share one MCP server config across several editors
Keep Claude Code, Cursor, VS Code, and Cline on the same MCP servers by rendering four editor files from one source, and see why a copied file loads zero servers.
Build an agent that calls APIs 5 guides
Agent loops and frameworks: Claude Agent SDK, OpenAI Agents SDK, LangGraph, Vercel AI SDK, Mastra, CrewAI; wrapping a typed SDK as tools, converting OpenAPI operations into function schemas, auth passthrough, pagination in tool results, parallel tool calls, long-running operations, streaming tool output, multi-step workflows (Arazzo as a description format), and calling SDKs directly versus through MCP.
Build a stateful API agent with LangGraph
Read a record in one turn and write it back in the next, after a restart, carrying only its id and version in the state LangGraph saves at each step.
Build a tool-calling loop with the Claude Agent SDK
Call two REST operations from one agent three ways: the Claude Agent SDK query loop, the Anthropic SDK tool runner, and a loop you write over the Messages API.
Choose between calling an SDK directly and using MCP
Wire three API operations into one agent as in-process typed tools and as MCP tools, then measure startup, tokens per request, and what a rename breaks under each.
Stream partial tool output back to a user
Show a user the chunks a tool is receiving while the model waits, through AI SDK data parts, your own server-sent events, or Anthropic's input streaming.
Wire an API client into the OpenAI Agents SDK
Register a typed client's operations as function tools, run the loop, hand off between two agents on one client, and keep a failed call from ending the run.
Constrain model output to a schema 3 guides
Making a model emit valid data: JSON Schema structured outputs, tool-call schemas used as output, GBNF and Lark grammars for constrained decoding (llama.cpp, vLLM, Outlines, guidance), repairing malformed or truncated JSON, validating with Zod, Pydantic or gubu and retrying, and generating grammars from a spec (the aontu GBNF and Lark output and the tabnas GBNF grammar as options).
Generate a GBNF grammar from an aontu schema
Generate a GBNF grammar from an aontu model through its JSON Schema export, and find with a corpus which constraints only vet still enforces.
Serve schema-constrained output with vLLM
Pin a decoding backend, send the schema in the field this vLLM release reads, and run a harness that validates every reply and refuses a silent fallback.
Validate JSON model output before you use it
Get a typed value out of a model response that is only mostly JSON, and refuse the responses that are the wrong shape instead of letting them into your code.
Evaluate and observe agents 7 guides
Evals (promptfoo, Braintrust, Inspect, LangSmith, custom harnesses), golden traces, task success rates across model providers, regression suites for tool use recorded from real traffic, tracing with OpenTelemetry GenAI semantic conventions (Langfuse, Phoenix, Helicone, OpenLLMetry), token and cost accounting, per-task budgets as cutoffs versus hard caps (the sdkgen cost feature as one example), caching tool results across steps, prompt caching, model routing.
Account for tokens and cost per agent task
Read each provider's usage fields into exclusive token buckets, price them from a table you keep, and roll the money up per task and per tenant.
Cache tool results across the steps of one agent run
Cache an agent's read tools by tenant, tool and arguments, clear the cache on every write, and record requests saved beside whether the answer stayed right.
Compare agent task success rates across model providers
Run one tool-using suite against several providers with only the model varied, and report success with an interval by case, tokens, and wall time per model.
Cut agent cost with provider prompt caching
Order the request so the stable prefix comes first and the growing conversation last, place the breakpoints, and measure cache reads against a baseline run.
Redact prompts and tool results in traces before export
Hash or drop prompts, tool results, and exception messages in one OpenTelemetry span processor, so a hosted backend gets the span tree and timings without the data.
Replay recorded API traffic in an agent regression suite
Record an agent's tool calls once, commit the cassette without the key, and replay it in CI so an uncovered request fails instead of reaching the network.
Run agent evals in CI without flaky failures
Rerun each eval case, gate the pull request on the aggregate against a band from nightly history, and keep outages and ordinary variance from reading as regressions.
Guard agents and add approvals 5 guides
The agent side of safety: prompt injection defence for tool results, web pages and documents, isolating untrusted content, output filtering, allow lists, human-in-the-loop approval before destructive calls, MCP elicitation, dry-run modes, sandboxing, least privilege per tool, spend and blast-radius limits, guardrail libraries (OpenAI Agents SDK guardrails, Guardrails AI, NeMo Guardrails, Llama Guard), and testing against an injection corpus.
Add a dry-run mode to an agent's write tools
Give every write tool a dry-run flag the runner owns, answer the dry run from the server, a fake transport or a recorded plan, and diff it against the audit log.
Handle MCP elicitation requests in your agent client
Let an MCP server ask the person before a destructive tool runs: declare the capability, render the schema as a form, and answer accept, decline, or cancel.
Require human approval before an agent calls a delete tool
Pause the run when the model calls a delete tool, show a person the exact arguments, resume with their decision, and test that a rejection deletes nothing.
Sandbox an agent's shell and code execution
Run what an agent executes inside a boundary with no credentials, a scratch filesystem and a closed network, in Docker, a sandbox service or an OS-level sandbox.
Sanitize tool results before they re-enter the prompt
Extract readable text, strip zero-width characters, normalize to NFKC, cut to a byte budget, and wrap the result in a delimiter the system prompt names as data.
Generate the client instead of writing it#
Retries, timeouts, pagination and auth are the same problems in every client. Voxgig generates them from your OpenAPI description, in 23 languages, from one model.