Use case

PromptOps And MCP Tool Gateway

Use Console as the control plane for prompt versioning, secure config storage, and converting OpenAPI specs into MCP and tool endpoints.

• Stack Console + Console SDK
• Pattern Platform · Tools
• Read ~10 min

Overview

As AI systems mature, teams need more than model access. They need prompt lifecycle control, encrypted configuration, and a standard way to turn existing APIs into reusable tools. Console covers those operational layers in one place.

This use case is for platform teams that want prompt changes, secret/config handling, and OpenAPI-to-MCP conversion managed centrally instead of scattered across apps.

When to reach for this use case

If your team needs the capabilities described above and you would rather build on proven primitives than wire one from scratch — this is the shape to start from.

Architecture

Console owns prompt deployments, config groups and items, MCP servers, and tool discovery. Console SDK gives app and platform teams a typed interface to render prompts, resolve config, and call these platform capabilities from CI pipelines or admin backends.

1. Manage Prompt Versions From Console

List prompt versions, compare them, and promote the right version into the right environment without changing application code.

import { ConsoleClient } from '@cognipeer/console-sdk';

const client = new ConsoleClient({
  apiKey: process.env.COGNIPEER_API_KEY!,
  baseURL: 'https://console.example.com',
});

const { prompt } = await client.prompts.get('incident-summary', {
  environment: 'staging',
});

const versions = await client.prompts.listVersions('incident-summary');
const comparison = await client.prompts.compare(
  'incident-summary',
  versions.versions[0].id,
  versions.versions[1].id,
);

await client.prompts.deploy('incident-summary', {
  action: 'activate',
  environment: 'prod',
  versionId: versions.versions[0].id,
  note: 'Promote the tested incident-summary prompt to production',
});

2. Store Secrets And Runtime Settings In Config

Console config groups are useful for provider secrets, webhook targets, or environment-specific runtime knobs that should not live in app source code.

const group = await client.config.createGroup({
  name: 'Incident Automation',
  tags: ['sre', 'automation'],
});

await client.config.createItem(group.key, {
  name: 'Jira API Token',
  value: process.env.JIRA_API_TOKEN!,
  isSecret: true,
  tags: ['jira'],
});

await client.config.createItem(group.key, {
  name: 'Default Severity Threshold',
  value: 'sev-2',
  tags: ['runtime'],
});

const resolved = await client.config.resolve({
  keys: ['cfg-jira-api-token', 'cfg-default-severity-threshold'],
});

console.log(resolved['cfg-default-severity-threshold'].value);

3. Convert OpenAPI Specs Into MCP Servers

Console can expose an uploaded OpenAPI spec as an MCP server. That gives agents and tools a consistent protocol surface instead of raw one-off HTTP integrations.

// Example Console workflow:
// 1. Open Console > MCP Servers
// 2. Upload the Jira or internal incident API OpenAPI spec
// 3. Console parses operations and creates MCP tools automatically
// 4. Agents can consume the generated MCP endpoint or import actions into the tool system

// Example generated action shapes from an OpenAPI spec:
// - createIncidentComment
// - getIncidentById
// - listServiceHealthChecks

// Console then exposes a tenant-scoped MCP endpoint for these actions.

Result

You get a platform operations pattern that:

• Versions and deploys prompts through Console
• Stores secrets and runtime settings in encrypted config groups
• Converts OpenAPI specs into MCP servers and reusable tool actions
• Reduces app-side duplication for prompt, config, and API integration management

---

Products used

This pattern combines 2 Cognipeer products.

Cognipeer Console

Console

Self-hosted AI control plane — routing, embeddings, vectors, files, guardrails, and tracing.

@cognipeer/console-sdk

Console SDK

Typed TypeScript client for every Console endpoint, with streaming support.

See also

• Console REST API — the prompt, config, and MCP endpoints behind the SDK calls above.
• Console architecture — where prompts, config, and the MCP hub sit in the control plane.

Related use cases

Platform · Gateway

Quota-Aware LLM Gateway

Run application traffic through Console with project-scoped quotas, model routing, and request-level visibility for cost control.

RAG · Platform

Vector RAG Operations Control Plane

Operate RAG pipelines through Console by combining file ingestion, vector index management, embeddings, and chat retrieval in one control surface.

Apps · Platform

AI-Powered Applications

Integrate AI capabilities into existing applications with OpenAI-compatible APIs, provider routing, and type-safe SDKs.

Platform · Governance

Enterprise AI Governance

Enforce guardrails, track usage, manage projects, and observe all AI operations from a single control plane.

See every pattern on the use case index, or browse all Cognipeer libraries.