MCP integration

Model Context Protocol

Give AIa real connection.

Bring tools, data and business systems into the agent’s working context.

A shared capability language lets AI discover, understand and use existing systems. Around ID Axis, IDENIFE designs the connections between model reasoning and business execution.

Explore an exchange

Your AI applicationID Axis

Tasks & context

Client A

Client B

Business serverDesign tools · data services · actions

Knowledge serverProject files · knowledge · templates

Connection architecture

Clear responsibilities.Useful collaboration.

The model needs to know what is possible. The system needs to know who is asking. MCP connects them while applications and services keep their own responsibilities.

Host application

Owns the user experience and model interaction, deciding how to assemble context and when approval is required. ID Axis workflows can organize tasks at this layer.

Host

Protocol client

Managed by the host, it connects to a particular server and handles version negotiation, capability discovery and message routing.

Client

Capability server

Adapts existing systems into focused tools, resources and prompt templates. Business logic and authorization remain on the service side.

Server

MCP standardizes the connection. Authorization decisions, task planning and business transactions remain implementation responsibilities.Architecture specification

Three protocol primitives

Actions. Context. Methods.Each has its own contract.

One design project may need a tool, a source document or a reusable review method. Choose a primitive to see how each reaches an application.

Illustrative exchange · no live request

“Find the approved design assets for this project.”

A tool describes its inputs before the client submits arguments. The server searches within the caller’s permissions and returns a result the application can use.

Client requesttools/call

{
  "jsonrpc": "2.0",
  "id": 21,
  "method": "tools/call",
  "params": {
    "name": "search_design_assets",
    "arguments": {
      "project": "GT-CONCEPT",
      "status": "approved"
    }
  }
}

tools/listtools/call

What the application receives

Design assets found

Two results, with versions and source references.

GT exterior concept

Image asset · v03

design://gt/concept/v03

Approved design brief

Project document · v02

design://gt/brief/v02

The model can propose a tool call. The application controls whether it runs.

Inspect the response structure

{
  "jsonrpc": "2.0",
  "id": 21,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "2 approved design assets found."
      }
    ],
    "structuredContent": {
      "assets": [
        {
          "uri": "design://gt/concept/v03",
          "version": "03"
        },
        {
          "uri": "design://gt/brief/v02",
          "version": "02"
        }
      ]
    }
  }
}

Examples use MCP 2025-11-25 after initialization. Tool names, resources and project data illustrate an integration design.Protocol reference

From connection to execution

Discover what is possible.Then make the right call.

A reliable integration aligns protocol versions, advertised capabilities and business boundaries. This sequence illustrates the session flow in version 2025-11-25.

01
Negotiate
Agree a supported version and capabilities, then signal readiness.
initialize
02
Discover
Read capability descriptions, input schemas and intended use.
tools/list
03
Authorize
Check identity, arguments and scope; request approval where needed.
Application policy
04
Execute
Invoke the service and return a result or an actionable error.
tools/call

The protocol carries the exchange; the host governs the action. The server still enforces its own access controls and business rules.

Lifecycle specification

Transport design

From a local toolto a remote service.

The protocol describes capabilities; the transport carries messages. Choose a path that fits deployment, identity and operations.

Local process

stdio

The client starts a server process and exchanges JSON-RPC messages over standard input and output. Suitable for desktop applications, local file tools and development environments.

A local process boundary for the tool
Credentials supplied through a controlled environment
Logs kept separate from protocol output

Network service

Streamable HTTP

An independent service carries requests and responses over HTTP, with optional SSE for streamed messages. Suitable for enterprise services and shared capabilities on controlled networks.

Access controlled by identity and resource
Connection, timeout and recovery handling
Protocol compatibility verified for the target client

Protected remote services can use the OAuth flow defined by MCP authorization. Identity providers, scopes and deployment choices are established during integration design.

Transport specification

IDENIFE’s enterprise integration approach

Make it connect.Make it dependable.

From enterprise AI to industrial design tools, integration involves more than a protocol wrapper. Our approach brings capability modelling, access mapping and operational governance into one design.

Turn business interfaces into capability contracts.

Start with a bounded use case. Define when a tool should be used, its arguments and the shape of its result. Schemas make the interface understandable to a model and verifiable by software.

inputSchema
outputSchema
Tool semantics

Connect identity to a precise data boundary.

Map the caller to tenant, project and resource scope. Separate read access from changes to business data. Existing system permissions still apply; a tool description is not an authorization decision.

Identity mapping
Least privilege
Read / write separation

Design for the failure paths of a real system.

Distinguish protocol errors, business denials and execution failures. Define timeouts and cancellation boundaries. For write operations, pair retry logic with idempotency to avoid duplicate actions.

Timeouts & cancellation
Idempotency
isError

Make each call understandable and reviewable.

Record the calling context, a summary of arguments, the version used and the outcome. Apply redaction and retention policies so diagnosis, review and improvement share a traceable record.

Call correlation
Version records
Redaction

Enterprise permissions do not disappear when AI is connected. Token audience checks, least privilege and server-side authorization belong in the integration design.

Authorization specification

Within the IDENIFE capability system

Models reason.Connections ground action.

Model & capability APIs

Provide reasoning and generation.

Send a defined task and receive model output or generated assets.

MCP integration

Connect tools and context.

Let an AI application discover capabilities and use them within access boundaries.

ID Axis integration

Organize tasks and execution.

Coordinate task progress, tool use and runtime state across multiple steps.

The next connection

Start with one real use case.

Bring your application, system boundaries and intended action. Define the first implementable capability contract together.

Discuss an MCP integration Read the developer documentation Explore request examples

Give AIa real connection.

Clear responsibilities.Useful collaboration.

Host application

Protocol client

Capability server

Actions. Context. Methods.Each has its own contract.

“Find the approved design assets for this project.”

Design assets found

Discover what is possible.Then make the right call.

Negotiate

Discover

Authorize

Execute

From a local toolto a remote service.

stdio

Streamable HTTP

Make it connect.Make it dependable.

Turn business interfaces into capability contracts.

Connect identity to a precise data boundary.

Design for the failure paths of a real system.

Make each call understandable and reviewable.

Models reason.Connections ground action.

Model & capability APIs

MCP integration

ID Axis integration

Start with one real use case.