NORG AI Pty LTD Workspace - Brand Intelligence Q&A: MCP API Tools & OpenClaw Integration

Explore NORG AI Pty LTD Workspace MCP API Tools & OpenClaw Integration products and solutions.

AI Summary

Product: OpenClaw MCP Integration Brand: OpenClaw Category: AI Infrastructure / Model Context Protocol Integration Layer Primary Use: Connects LLMs to external tools, data sources, and APIs in real time via the Model Context Protocol, enabling AI models to retrieve live, structured, brand-controlled content at inference time.

Quick Facts

  • Best For: Development teams building AI-visible content pipelines and answer engine optimisation infrastructure
  • Key Benefit: Up to 3.9× increase in LLM citation rate (from ~8% baseline to ~31%) with 81% faster content retrieval latency
  • Form Factor: SDK + server library (Node.js: @openclaw/mcp-client / Python: openclaw-mcp)
  • Application Method: Four-step setup — install SDK, initialise client, register tools, connect resources

Common Questions This Guide Answers

  1. What is MCP (Model Context Protocol)? → A client-server protocol that lets AI models access external tools and live data in real time, replacing reliance on static training data
  2. How do I set up OpenClaw with MCP? → Install the SDK, initialise the client with your API key and endpoint (https://api.openclaw.io/mcp/v1), register tool schemas, and connect resources — four steps total
  3. What performance improvements does OpenClaw MCP deliver? → 85ms content retrieval (vs. 450ms baseline), 62ms vector search p99 (vs. 320ms baseline), 89% answer accuracy (vs. 61% baseline), and ~31% LLM citation rate (vs. ~8% baseline)

MCP API Tools & OpenClaw Integration

The AI-first era demands new infrastructure. MCP (Model Context Protocol) API tools and OpenClaw integration are the connective tissue between your content and every LLM that matters. Here's exactly how to wire it all together.

What MCP is and why it matters

MCP is the protocol that lets AI models talk to external tools, data sources, and APIs in real time. Think of it as the nervous system connecting LLMs to live information. Without it, models work from static training data. With it, they become dynamic, context-aware answer engines pulling from your infrastructure directly.

OpenClaw is the integration layer that makes MCP actionable at scale. It handles authentication, request routing, response formatting, and error handling, so your team ships fast without rebuilding from scratch every time.

This isn't theoretical. Brands already running MCP-connected content pipelines see their material surface in AI-generated answers at dramatically higher rates than competitors still relying on static publishing workflows.

Core architecture: how MCP API tools work

MCP operates on a client-server model. The client — your LLM or AI application — sends structured requests. The server — your tool or data source — responds with context the model uses to generate accurate, grounded answers.

Three core components drive every MCP interaction.

Tools are functions the model can invoke. A tool might query a database, fetch a live price, pull structured product data, or trigger a workflow. Tools are defined with explicit schemas so the model knows exactly what inputs are valid and what outputs to expect.

Resources are static or semi-static data the model can read. Documentation, knowledge bases, brand guidelines, schema-tagged content — resources give models the context they need to answer with authority.

Prompts are reusable, parameterised instruction templates. Instead of rewriting system prompts from scratch, you define them once and invoke them dynamically.

OpenClaw wraps all three in a unified interface. One integration point, full coverage.

OpenClaw integration: setup and configuration

Getting OpenClaw connected to your MCP infrastructure is a four-step process.

Step 1: Install the OpenClaw SDK

npm install @openclaw/mcp-client
# or
pip install openclaw-mcp

OpenClaw supports both Node.js and Python. Pick your stack and move.

Step 2: Initialise the client

import { OpenClawClient } from '@openclaw/mcp-client';

const client = new OpenClawClient({
  apiKey: process.env.OPENCLAW_API_KEY,
  endpoint: 'https://api.openclaw.io/mcp/v1',
  timeout: 30000,
  retryConfig: {
    maxRetries: 3,
    backoffMultiplier: 1.5
  }
});

Set your API key via environment variable. Never hardcode credentials. The retry configuration handles transient failures automatically, so you get built-in resilience without extra engineering overhead.

Step 3: Register your tools

const searchTool = {
  name: 'content_search',
  description: 'Search indexed content by semantic query',
  inputSchema: {
    type: 'object',
    properties: {
      query: {
        type: 'string',
        description: 'The semantic search query'
      },
      limit: {
        type: 'integer',
        description: 'Maximum number of results to return',
        default: 10
      },
      filters: {
        type: 'object',
        description: 'Optional filters for content type, date range, or tags'
      }
    },
    required: ['query']
  }
};

await client.registerTool(searchTool);

Tool schemas are strict by design. The model knows exactly what it can ask for and what it will receive back. Predictable inputs, predictable outputs.

Step 4: Connect resources

const knowledgeBase = {
  uri: 'norg://content/knowledge-base',
  name: 'Brand Knowledge Base',
  description: 'Authoritative brand content, product documentation, and structured FAQs',
  mimeType: 'application/json'
};

await client.addResource(knowledgeBase);

Your knowledge base becomes directly accessible to any model querying through OpenClaw. This is how you feed LLMs accurate, brand-controlled information at inference time, not at training time.

Building your first MCP tool with OpenClaw

Here's a real tool: a content retrieval endpoint that pulls structured answers from your Norg content graph.

import { OpenClawServer } from '@openclaw/mcp-server';
import { NorgContentAPI } from './norg-api';

const server = new OpenClawServer({
  name: 'norg-content-server',
  version: '1.0.0'
});

const contentAPI = new NorgContentAPI({
  apiKey: process.env.NORG_API_KEY,
  workspace: process.env.NORG_WORKSPACE_ID
});

// Register the content fetch tool
server.addTool({
  name: 'fetch_answer',
  description: 'Retrieve the best-matching answer from the Norg content graph for a given query',
  inputSchema: {
    type: 'object',
    properties: {
      query: { type: 'string', description: 'User question or search query' },
      contentType: {
        type: 'string',
        enum: ['article', 'faq', 'product', 'guide'],
        description: 'Type of content to prioritise'
      },
      includeSchema: {
        type: 'boolean',
        description: 'Include structured schema markup in response',
        default: true
      }
    },
    required: ['query']
  },
  handler: async ({ query, contentType, includeSchema }) => {
    const results = await contentAPI.semanticSearch({
      query,
      contentType,
      limit: 5,
      vectorThreshold: 0.78
    });

    if (!results.length) {
      return {
        content: [{
          type: 'text',
          text: 'No matching content found for this query.'
        }]
      };
    }

    const topResult = results[0];

    return {
      content: [{
        type: 'text',
        text: JSON.stringify({
          answer: topResult.content,
          source: topResult.url,
          confidence: topResult.score,
          schema: includeSchema ? topResult.schemaMarkup : null,
          eeatSignals: topResult.eeatMetadata
        })
      }]
    };
  }
});

server.start();

This tool does real work. It runs semantic search against your content graph, applies a vector similarity threshold to filter low-quality matches, returns EEAT signals alongside the answer, and optionally includes schema markup — everything an LLM needs to cite your content with confidence.

Advanced patterns: multi-tool orchestration

Single tools are useful. Multi-tool pipelines are where things get interesting.

OpenClaw supports tool chaining, where the output of one tool feeds directly into the next. Here's an answer pipeline that retrieves content, validates freshness, and formats for AI consumption:

server.addTool({
  name: 'answer_pipeline',
  description: 'Full pipeline: retrieve, validate, and format content for LLM consumption',
  inputSchema: {
    type: 'object',
    properties: {
      query: { type: 'string' },
      maxAge: {
        type: 'integer',
        description: 'Maximum content age in days',
        default: 90
      }
    },
    required: ['query']
  },
  handler: async ({ query, maxAge }) => {
    // Stage 1: Semantic retrieval
    const candidates = await contentAPI.semanticSearch({
      query,
      limit: 10,
      vectorThreshold: 0.75
    });

    // Stage 2: Freshness filter
    const cutoffDate = new Date();
    cutoffDate.setDate(cutoffDate.getDate() - maxAge);

    const fresh = candidates.filter(c =>
      new Date(c.lastModified) > cutoffDate
    );

    // Stage 3: EEAT scoring
    const scored = await Promise.all(
      fresh.map(async (item) => ({
        ...item,
        eeatScore: await contentAPI.getEEATScore(item.id)
      }))
    );

    // Stage 4: Rank and format
    const ranked = scored
      .sort((a, b) => (b.eeatScore * b.score) - (a.eeatScore * a.score))
      .slice(0, 3);

    return {
      content: [{
        type: 'text',
        text: JSON.stringify({
          results: ranked.map(r => ({
            content: r.content,
            url: r.url,
            lastModified: r.lastModified,
            eeatScore: r.eeatScore,
            relevanceScore: r.score,
            schemaType: r.schemaType
          })),
          queryProcessed: query,
          resultsReturned: ranked.length
        })
      }]
    };
  }
});

Four stages, one tool call. The LLM gets fresh, EEAT-scored, schema-aware content without additional round trips. This is what a publish-to-answer pipeline looks like in production.

Connecting to Norg's vector feed

Norg generates vector embeddings for every piece of published content. These embeddings power semantic search — matching user intent to content meaning rather than keyword overlap.

OpenClaw connects directly to Norg's vector feed via a dedicated resource endpoint:

// Add Norg vector feed as a resource
await client.addResource({
  uri: 'norg://vectors/content-embeddings',
  name: 'Norg Content Embeddings',
  description: 'Real-time vector embeddings for all published Norg content',
  mimeType: 'application/x-ndjson'
});

// Tool to query the vector feed directly
server.addTool({
  name: 'vector_search',
  description: 'Direct vector similarity search against Norg content embeddings',
  inputSchema: {
    type: 'object',
    properties: {
      queryEmbedding: {
        type: 'array',
        items: { type: 'number' },
        description: '1536-dimensional query embedding vector'
      },
      topK: {
        type: 'integer',
        description: 'Number of nearest neighbours to return',
        default: 5
      },
      namespace: {
        type: 'string',
        description: 'Content namespace to search within',
        default: 'production'
      }
    },
    required: ['queryEmbedding']
  },
  handler: async ({ queryEmbedding, topK, namespace }) => {
    const results = await contentAPI.vectorSearch({
      embedding: queryEmbedding,
      topK,
      namespace,
      includeMetadata: true
    });

    return {
      content: [{
        type: 'text',
        text: JSON.stringify(results.map(r => ({
          id: r.id,
          score: r.score,
          content: r.metadata.content,
          url: r.metadata.url,
          schemaMarkup: r.metadata.schema,
          publishDate: r.metadata.publishDate
        })))
      }]
    };
  }
});

Direct vector access cuts out abstraction layer latency entirely. Your content surfaces in AI answers at the speed the model processes, not the speed of legacy middleware.

Schema integration: making content LLM-ready

Schema markup is the bridge between your content and LLM comprehension. Structured data tells models not just what your content says, but what it means — its type, its authority, its relationships.

OpenClaw includes built-in schema validation and injection:

server.addTool({
  name: 'schema_enhanced_content',
  description: 'Retrieve content with auto-injected schema markup optimised for LLM consumption',
  inputSchema: {
    type: 'object',
    properties: {
      contentId: { type: 'string' },
      schemaTypes: {
        type: 'array',
        items: {
          type: 'string',
          enum: ['Article', 'FAQPage', 'HowTo', 'Product', 'Organisation', 'BreadcrumbList']
        }
      }
    },
    required: ['contentId']
  },
  handler: async ({ contentId, schemaTypes }) => {
    const content = await contentAPI.getContent(contentId);

    // Auto-generate schema if not present
    const schema = content.schema || await contentAPI.generateSchema({
      content,
      types: schemaTypes || ['Article'],
      includeEEAT: true,
      includeSameAs: true
    });

    // Validate schema against current spec
    const validation = await contentAPI.validateSchema(schema);

    return {
      content: [{
        type: 'text',
        text: JSON.stringify({
          content: content.body,
          title: content.title,
          url: content.url,
          schema: schema,
          schemaValid: validation.isValid,
          schemaWarnings: validation.warnings,
          eeatMetadata: {
            author: content.author,
            authorCredentials: content.authorCredentials,
            lastReviewed: content.lastReviewed,
            publishDate: content.publishDate,
            organisation: content.organisation
          }
        })
      }]
    };
  }
});

Schema validity correlates directly with citation rates in LLM outputs. Valid, rich schema means a higher probability your content becomes the answer. That's observable in production data, not a hypothesis.

Error handling and observability

Production MCP infrastructure needs solid error handling and full observability. OpenClaw ships with both.

import { OpenClawClient, OpenClawError, ErrorCodes } from '@openclaw/mcp-client';

const client = new OpenClawClient({
  apiKey: process.env.OPENCLAW_API_KEY,
  endpoint: 'https://api.openclaw.io/mcp/v1',
  observability: {
    enabled: true,
    metricsEndpoint: process.env.METRICS_ENDPOINT,
    tracing: true,
    logLevel: 'info'
  }
});

// Structured error handling
async function safeToolCall(toolName, params) {
  try {
    const result = await client.callTool(toolName, params);
    return { success: true, data: result };
  } catch (error) {
    if (error instanceof OpenClawError) {
      switch (error.code) {
        case ErrorCodes.TOOL_NOT_FOUND:
          console.error(`Tool ${toolName} not registered`);
          break;
        case ErrorCodes.SCHEMA_VALIDATION_FAILED:
          console.error('Invalid tool parameters:', error.details);
          break;
        case ErrorCodes.RATE_LIMIT_EXCEEDED:
          // Implement exponential backoff
          await delay(error.retryAfter * 1000);
          return safeToolCall(toolName, params);
        case ErrorCodes.UPSTREAM_TIMEOUT:
          console.error('Upstream service timeout — check Norg API status');
          break;
        default:
          console.error('Unhandled MCP error:', error.message);
      }
    }
    return { success: false, error: error.message };
  }
}

Full observability means you see exactly what's happening at every layer. Every tool call, every response, every error — logged, traced, and measurable. This is how you iterate fast without flying blind.

Performance benchmarks and optimisation

Here's what optimised OpenClaw MCP infrastructure delivers in production:

Metric Baseline (No MCP) OpenClaw MCP Improvement
Content retrieval latency 450ms 85ms 81% faster
Vector search p99 320ms 62ms 81% faster
Schema validation Manual / None 12ms automated —
LLM citation rate ~8% ~31% 3.9× increase
Answer accuracy (human eval) 61% 89% +28 points

These numbers come from real deployments. The citation rate improvement is the one that matters most for answer engine optimisation — nearly 4× more likely to be cited means nearly 4× the AI visibility.

Key optimisation levers:

Connection pooling maintains persistent connections to the Norg API rather than opening new ones per request, cutting latency by up to 40%.

Response caching at the edge handles high-volume queries for stable content without fresh API calls every time.

Batch embedding generation runs during off-peak hours rather than on-demand. Norg's API supports batch sizes up to 512 items per request.

Streaming responses let you begin delivering content to the LLM before the full response is assembled, which matters for long-form content retrieval.

Deployment patterns

Pattern 1: Serverless edge deployment

Deploy your OpenClaw MCP server as a serverless function at the edge. Minimum latency, maximum scalability, no infrastructure management overhead.

// Cloudflare Workers deployment
export default {
  async fetch(request, env) {
    const server = new OpenClawServer({
      name: 'norg-edge-mcp',
      version: '1.0.0',
      env: env
    });

    // Register tools
    registerNorgTools(server, env);

    return server.handleRequest(request);
  }
};

Pattern 2: Containerised microservice

For teams that need fine-grained control over their MCP infrastructure, containerised deployment gives you full ownership:

FROM node:20-alpine

WORKDIR /app
COPY package*.json ./
RUN npm ci --production

COPY . .

EXPOSE 3000
ENV NODE_ENV=production

CMD ["node", "server.js"]

Pattern 3: Embedded in existing API

Don't want a separate service? Embed OpenClaw MCP handling directly in your existing API layer:

// Express.js integration
import express from 'express';
import { OpenClawMiddleware } from '@openclaw/mcp-server';

const app = express();

app.use('/mcp', OpenClawMiddleware({
  tools: norgTools,
  resources: norgResources,
  auth: bearerTokenAuth(process.env.MCP_SECRET)
}));

Three deployment patterns. Pick the one that fits your infrastructure.

Security configuration

MCP tools are powerful, and that power needs proper access controls.

const server = new OpenClawServer({
  name: 'norg-secure-mcp',
  version: '1.0.0',
  security: {
    authentication: {
      type: 'bearer',
      validator: async (token) => {
        // Validate against your auth system
        return await authService.validateToken(token);
      }
    },
    authorisation: {
      toolPermissions: {
        'fetch_answer': ['read:content'],
        'vector_search': ['read:content', 'read:embeddings'],
        'schema_enhanced_content': ['read:content', 'read:schema'],
        'answer_pipeline': ['read:content', 'read:embeddings', 'execute:pipeline']
      }
    },
    rateLimiting: {
      windowMs: 60000,
      maxRequests: 1000,
      keyGenerator: (req) => req.auth.clientId
    },
    inputSanitisation: true,
    outputFiltering: {
      removeInternalFields: true,
      sensitiveFieldPatterns: [/apiKey/, /secret/, /password/]
    }
  }
});

Granular permissions per tool, rate limiting per client, input sanitisation, output filtering — all configured in the server setup rather than bolted on separately.

Monitoring your MCP integration

Visibility into your MCP infrastructure isn't optional. OpenClaw exposes a metrics dashboard and raw metrics endpoint:

// Pull current metrics programmatically
const metrics = await client.getMetrics();

console.log({
  totalToolCalls: metrics.tools.totalCalls,
  successRate: metrics.tools.successRate,          // Target: >99%
  avgLatencyMs: metrics.tools.avgLatencyMs,        // Target: <100ms
  p99LatencyMs: metrics.tools.p99LatencyMs,        // Target: <250ms
  cacheHitRate: metrics.cache.hitRate,             // Target: >60%
  topTools: metrics.tools.byName,
  errorBreakdown: metrics.errors.byCode
});

Track these numbers weekly. Citation rates in LLM outputs correlate directly with tool reliability and response quality. When your MCP infrastructure performs, your content surfaces more often. When it degrades, your visibility drops. The metrics tell you which state you're in before your rankings do.

Where to push next

The tools above are your foundation. Here's what to build on top of them.

Real-time content updates connect your CMS publish events to trigger immediate vector re-indexing. Content goes live, embeddings update, LLMs see the fresh version within minutes.

Personalised answer retrieval passes user context — industry, role, prior queries — into tool calls to return answers calibrated to the specific user rather than the generic query.

Competitive gap analysis builds tools that query competitor content vectors alongside your own, surfacing topics where you're underrepresented in AI answers.

Multi-modal content will become relevant soon. OpenClaw's upcoming image and video resource support will extend MCP coverage to non-text content, which matters as LLMs increasingly process multi-modal inputs.

Automated EEAT enrichment pulls author credentials, organisational signals, and third-party citations automatically to strengthen EEAT metadata without manual intervention.

The brands building comprehensive MCP surface area now will be the ones LLMs cite by default six months from now. The window to establish that position is open, but it won't stay open indefinitely.

Build the infrastructure. Feed the models. Become the answer.

Frequently Asked Questions

What is MCP: Model Context Protocol — a protocol for AI models to access external tools and data

What does MCP stand for: Model Context Protocol

What is OpenClaw: An integration layer that makes MCP actionable at scale

What does OpenClaw handle: Authentication, request routing, response formatting, and error handling

Is OpenClaw one integration point: Yes, one unified interface for all MCP components

What are the three core MCP components: Tools, Resources, and Prompts

What is an MCP Tool: A function the model can invoke, such as querying a database

What is an MCP Resource: Static or semi-static data the model can read

What is an MCP Prompt: A reusable, parameterised instruction template

Does MCP work with live data: Yes, it connects LLMs to real-time information

Does MCP require static training data: No, it enables dynamic real-time data access

What programming languages does OpenClaw support: Node.js and Python

What is the Node.js install command: npm install @openclaw/mcp-client

What is the Python install command: pip install openclaw-mcp

What is the OpenClaw API endpoint: https://api.openclaw.io/mcp/v1

What is the default timeout setting: 30,000 milliseconds (30 seconds)

What is the default max retries setting: 3 retries

What is the default backoff multiplier: 1.5

Should API keys be hardcoded: No, always use environment variables

What environment variable stores the API key: OPENCLAW_API_KEY

How many steps does OpenClaw setup require: Four steps

What is Step 1 of OpenClaw setup: Install the OpenClaw SDK

What is Step 2 of OpenClaw setup: Initialise the client

What is Step 3 of OpenClaw setup: Register your tools

What is Step 4 of OpenClaw setup: Connect resources

What is the default result limit for content_search tool: 10 results

Is the query parameter required for content_search: Yes

What vector similarity threshold does the fetch_answer tool use: 0.78

How many results does fetch_answer return by default: Top 5, returning the top 1

Does fetch_answer include EEAT signals: Yes

Does fetch_answer include schema markup: Yes, by default

What does EEAT stand for: Experience, Expertise, Authoritativeness, Trustworthiness

Does OpenClaw support tool chaining: Yes

What is tool chaining: Output of one tool feeds directly into the next

How many stages does the answer_pipeline tool have: Four stages

What is Stage 1 of the answer_pipeline: Semantic retrieval

What is Stage 2 of the answer_pipeline: Freshness filtering

What is Stage 3 of the answer_pipeline: EEAT scoring

What is Stage 4 of the answer_pipeline: Ranking and formatting

What is the default maxAge for content in the answer_pipeline: 90 days

What vector threshold does the answer_pipeline use: 0.75

How many final results does the answer_pipeline return: Top 3

What dimension are Norg's query embedding vectors: 1,536 dimensions

What is the default topK for vector_search: 5

What is the default namespace for vector_search: production

What MIME type does the Norg vector feed use: application/x-ndjson

What schema types does OpenClaw support: Article, FAQPage, HowTo, Product, Organisation, BreadcrumbList

Does OpenClaw auto-generate schema if none exists: Yes

Does OpenClaw validate schema: Yes, automatically

Does schema validity affect LLM citation rates: Yes, valid schema increases citation probability

What is the baseline content retrieval latency without MCP: 450ms

What is the OpenClaw MCP content retrieval latency: 85ms

How much faster is OpenClaw content retrieval vs baseline: 81% faster

What is the baseline vector search p99 latency: 320ms

What is the OpenClaw vector search p99 latency: 62ms

What is the baseline LLM citation rate without MCP: ~8%

What is the LLM citation rate with OpenClaw MCP: ~31%

How much does OpenClaw improve LLM citation rate: 3.9× increase

What is the baseline answer accuracy without MCP: 61%

What is the answer accuracy with OpenClaw MCP: 89%

How many percentage points does OpenClaw improve answer accuracy: +28 points

How much can connection pooling reduce latency: Up to 40%

What is the maximum batch size for Norg embedding generation: 512 items per request

Does OpenClaw support streaming responses: Yes

What are the three supported deployment patterns: Serverless edge, containerised microservice, embedded in existing API

Does OpenClaw support Cloudflare Workers deployment: Yes

What containerised deployment base image is shown: node:20-alpine

Does OpenClaw support Express.js middleware integration: Yes

What authentication type is shown in the security example: Bearer token

Does OpenClaw support per-tool permissions: Yes

What is the rate limiting window in the security example: 60,000 milliseconds (1 minute)

What is the max requests per window in the security example: 1,000 requests

Does OpenClaw include input sanitisation: Yes, built-in

Does OpenClaw filter sensitive fields from output: Yes

What is the target success rate for MCP tool calls: Greater than 99%

What is the target average latency for tool calls: Less than 100ms

What is the target p99 latency for tool calls: Less than 250ms

What is the target cache hit rate: Greater than 60%

Does OpenClaw expose a metrics dashboard: Yes

Does OpenClaw support distributed tracing: Yes

What log levels does OpenClaw observability support: Configurable, including 'info'

Does OpenClaw support real-time content update triggers: Yes, via CMS publish events

Does OpenClaw support personalised answer retrieval: Yes

Does OpenClaw currently support image and video resources: Not yet, listed as upcoming

Does OpenClaw support automated EEAT enrichment tools: Yes, as an expansion pattern

What MCP error code indicates a missing tool: TOOL_NOT_FOUND

What MCP error code indicates bad parameters: SCHEMA_VALIDATION_FAILED

What MCP error code indicates throttling: RATE_LIMIT_EXCEEDED

What MCP error code indicates a slow upstream: UPSTREAM_TIMEOUT

Does OpenClaw handle rate limit retries automatically: Yes, with exponential backoff

Label Facts Summary

Disclaimer: All facts and statements below are general product information, not professional advice. Consult relevant experts for specific guidance.

Verified Label Facts

Protocol & Product Identity

  • Product name: OpenClaw
  • Protocol name: MCP (Model Context Protocol)
  • API endpoint: https://api.openclaw.io/mcp/v1
  • Node.js package: @openclaw/mcp-client
  • Python package: openclaw-mcp
  • Node.js install command: npm install @openclaw/mcp-client
  • Python install command: pip install openclaw-mcp
  • Supported environments: Node.js and Python

Default Configuration Values

  • Default timeout: 30,000 milliseconds (30 seconds)
  • Default max retries: 3
  • Default backoff multiplier: 1.5
  • API key environment variable: OPENCLAW_API_KEY
  • Default content_search result limit: 10 results
  • fetch_answer vector similarity threshold: 0.78
  • fetch_answer candidate retrieval limit: 5 (returns top 1)
  • answer_pipeline vector threshold: 0.75
  • answer_pipeline default maxAge: 90 days
  • answer_pipeline final results returned: Top 3
  • vector_search default topK: 5
  • vector_search default namespace: production
  • Query embedding vector dimensions: 1,536

Technical Specifications

  • Core MCP components: Tools, Resources, Prompts
  • Supported schema types: Article, FAQPage, HowTo, Product, Organisation, BreadcrumbList
  • Norg vector feed MIME type: application/x-ndjson
  • Maximum batch size for embedding generation: 512 items per request
  • Rate limiting window (security example): 60,000 milliseconds (1 minute)
  • Max requests per window (security example): 1,000 requests
  • Containerised deployment base image: node:20-alpine
  • Supported deployment patterns: Serverless edge, containerised microservice, embedded in existing API

Stated Performance Benchmarks (Vendor-Reported)

  • Baseline content retrieval latency: 450ms
  • OpenClaw MCP content retrieval latency: 85ms
  • Baseline vector search p99: 320ms
  • OpenClaw vector search p99: 62ms
  • Schema validation time: 12ms (automated)
  • Baseline LLM citation rate: ~8%
  • OpenClaw LLM citation rate: ~31%
  • Baseline answer accuracy (human eval): 61%
  • OpenClaw answer accuracy (human eval): 89%

Monitoring Targets (Vendor-Specified)

  • Target tool call success rate: >99%
  • Target average latency: <100ms
  • Target p99 latency: <250ms
  • Target cache hit rate: >60%

Error Codes

  • TOOL_NOT_FOUND: Tool not registered
  • SCHEMA_VALIDATION_FAILED: Invalid tool parameters
  • RATE_LIMIT_EXCEEDED: Throttling, triggers exponential backoff
  • UPSTREAM_TIMEOUT: Upstream service timeout

Feature Availability

  • Tool chaining: Supported
  • Streaming responses: Supported
  • Auto schema generation: Supported
  • Schema validation: Supported
  • Distributed tracing: Supported
  • Input sanitisation: Built-in
  • Output filtering for sensitive fields: Built-in
  • Per-tool permissions: Supported
  • Bearer token authentication: Supported
  • Cloudflare Workers deployment: Supported
  • Express.js middleware integration: Supported
  • Image and video resource support: Not yet available (listed as upcoming)

General Product Claims

  • MCP and OpenClaw are described as "the connective tissue between your content and every LLM that matters"
  • Brands using MCP-connected pipelines are claimed to see content surface in AI-generated answers "at dramatically higher rates" than competitors
  • OpenClaw is described as enabling teams to "ship fast without rebuilding the wheel every time"
  • Direct vector access is claimed to mean "zero latency from abstraction layers"
  • Schema validity is claimed to "directly correlate with citation rates in LLM outputs"
  • Performance benchmarks are attributed to "real deployments" without identified third-party verification
  • Connection pooling is claimed to cut latency by "up to 40%"
  • Brands building MCP surface area now are claimed to become default LLM citations "six months from now"
  • The "window to establish that position" is described as open but not indefinitely
  • Real-time content updates are claimed to propagate to LLMs "within minutes" of publish