Connect inference clients

Inference and MCP connections

An inference connection chooses which service generates your agent's answers. Netra MCP gives an agent observation tools or separately permissioned customer key and workspace actions. You can connect MCP while leaving the agent's existing inference provider in place.

Hermes Agent

Hermes supports custom OpenAI-compatible endpoints. Run its provider setup, choose Custom endpoint (under More providers in some versions), select Chat Completions when asked for the API mode, and enter the Netra connection values. See Hermes provider documentation for the current wizard.

Command: hermes model
Provider: Custom endpoint
API mode: OpenAI Chat Completions
Base URL: https://api.netraruntime.com/v1
API key: <YOUR_NETRA_API_KEY>
Model: deepseek/deepseek-v4-flash-0731

Store the key through the client's credential configuration. Confirm the model appears in Netra's current catalog and use the provider/model's actual context limits. A compatible endpoint still needs to support the features your agent uses, such as tool calling. Auxiliary models or tools in an agent framework may have separate provider settings and billing.

Claude Code

Connect Anthropic SDKs and Claude Code using the Messages API guide. Set the base URL to https://api.netraruntime.com, authenticate with your Netra API key and choose a Netra model ID. The guide includes model-role settings, tools, thinking and supported API features.

The supported inference subset does not prevent a compatible Claude Code MCP client from using the separate Netra observation MCP with a bearer-authenticated remote HTTP connection.

Codex

Current Codex custom-provider configuration uses the Responses protocol. Netra supports a stateless DeepSeek Responses API, including text, V4.1 images, streaming, and function tools. Full Codex compatibility is not established: features such as stored conversations and encrypted reasoning items are unsupported. Check the client's required features against that guide. Do not use legacy wire_api = "chat" configuration as a substitute. See the official Codex configuration reference.

Codex can keep its existing model provider and connect to Netra MCP separately when the client supports its remote HTTP bearer configuration. Follow Connect Netra MCP for URL, authentication, visibility, and monitoring limits.

Continue after reasoning and tools

Automatic tool choice (tool_choice: "auto"), forced tool calls, tool-result continuation, and strict JSON schema output are supported for DeepSeek V4 Flash 0731. Use deepseek/deepseek-v4-flash-0731 as the model ID. See Models and pricing for the current capability guidance.

Keep the returned reasoning details, including signatures and encrypted blocks, and matching tool-call IDs in continuation history. The example below applies after a model has returned a tool call.

Preserve the actual assistant message returned by the provider, including its tool_calls and complete reasoning_details sequence. Do not create placeholder signatures or encrypted blocks. Append each tool result with the exact matching tool_call_id, then send the continuation. This example starts from your real response and real tool result:

assistant = response_json["choices"][0]["message"]  # Raw API response; keep nulls too
messages.append(assistant)
for tool_call in assistant.get("tool_calls") or []:
    result = run_your_validated_tool(tool_call)  # Your own implementation
    messages.append({
        "role": "tool",
        "tool_call_id": tool_call["id"],
        "content": result,
    })
continuation = client.chat.completions.create(
    model=model,
    messages=messages,
    tools=tools,
    extra_body={"reasoning": {"effort": "high"}},
)

For streaming, concatenate the received detail arrays in order and retain the provider's tool IDs while assembling argument fragments. Follow the reasoning preservation contract. Playground can accept manually supplied tool results and continues only after every pending call has its matching result; it does not execute external tools.

reasoning.exclude: true removes returned reasoning but still generates and bills it. Excluded detail blocks cannot be reconstructed for later history. Keep reasoning included for tool turns whose provider requires those blocks in the continuation.