MCP Registry/Gateway

The Model Context Protocol (MCP) is a standardized way for AI models to securely interact with external tools, services, and data sources.

Within Javelin, MCP acts as a bridge between LLMs and external systems, enabling richer AI capabilities while enforcing enterprise-grade security, policy compliance, and continuous vulnerability checks.

MCP Configuration Guide

Field Descriptions

Name	Type	Required	Default	Description
name	string	Yes	—	Unique key for this MCP server (for example, deepwiki)
description	string	No	—	Human-readable description
type	string	Yes	—	MCP server type/transport (for example, streamable-http)
endpoint	string	Yes	—	Base URL for the MCP server
is_active	boolean	No	true	Whether the MCP registry is enabled
config.authorization_token	string	No	—	Optional; credential used to authenticate with the MCP server, if needed.

Policy Fields

Name	Type	Required	Default	Description
dlp
prompt_safety
indirect_prompt_safety

Tool Enable/Disable Payload

Use this payload to enable or disable a specific tool for an MCP server.

tool:
  enabled: true

Name	Type	Required	Description
enabled	boolean	Yes	Whether the tool is enabled for this MCP server

MCP Benefits

Enhanced AI Capabilities

• Tool Integration: Connect AI to APIs, databases, and enterprise services.

• Controlled Access: Enable/disable specific tools per MCP server, ensuring only approved tools are usable

• Application-Centric Usage: All MCP interactions are tied to the Application that invoked them, keeping usage, logs, and policies scoped to the right context.

Enterprise Security

• Policy Enforcement: Apply filters (e.g., Malicious Instruction Injections, Data Protection, Security Filters).

• Audit Trail: Every request and tool invocation is logged.

• Vulnerability Scan: Whenever you enable/disable a tool or open the Tools tab, Javelin automatically runs a vulnerability scan to detect security risks in that tool.

Operational Efficiency

• Simple Management: Easy setup of servers and tool configs.

• Monitoring & Analytics: Usage tracking, vulnerability status, and performance insights.

MCP Features

Tool Management

• Registration – Add new MCP servers.

• Configuration – Define endpoints, tokens, and tool details.

• Tool Status & Vulnerabilities – Enable/disable tools and review vulnerability scan results.

Security Policies

• Malicious Instruction Injections – Defend against jailbreaks or injection attempts.

• Data Protection – Prevent sensitive data leakage.

• Security Filters – Protect against MCP Tool security vulnerabilities.

MCP Registry

In Javelin, MCP registries define how your gateway connects to external MCP servers and exposes their tools to applications.

Each registry includes connection details, authentication credentials, and baseline policy controls. You can also selectively enable tools on a per-registry basis to safely extend application capabilities.

Creating an MCP Registry

1. Navigate to the MCP Registries page within your gateway.

2. Click Add MCP Registry button.

3. In the Details tab, fill in the required fields.

The Details tab provides the core configuration for your MCP Registry. It includes:

• Name: Unique identifier for your MCP server (e.g., deepwiki, github).

• URL: The base URL of the MCP server.

• Request URL: The endpoint Javelin uses to send MCP requests for this server.

  • This URL is automatically generated after registration and is required when connecting LLMs to MCP tools.

  • Example: https://api.javelin.live/v1/mcp/deepwiki

• Description: A human-readable purpose or context for the MCP registry.

• Authorization Token: Token used to authenticate with the MCP server.

  • Store this securely, as it may grant direct access to the MCP server’s tools.

  • The token can be updated at any time if compromised.

This tab serves as the foundation for connecting Javelin to your MCP server, ensuring all requests are routed securely.

1. Click Save to create the registry.

Once an MCP Registry is created, it will appear in the MCP Registries list.

From here, selecting a registry takes you to its dedicated page where you can configure and manage it further.

Tools Tab

The Tools tab allows you to:

• View all tools exposed by the registered MCP server.

• Enable or disable individual tools for controlled access.

• See Vulnerability scan results for each tool.

Whenever you enable/disable a tool or open the Tools tab, Javelin automatically runs a vulnerability scan on that tool. The results are displayed directly in this tab, showing potential security vulnerabilities.

This ensures that every tool made available through MCP is continuously assessed for risk, giving developers and admins clear visibility into tool security posture before use.

Policy Tab

The Policy tab displays all MCP Registry-level policies currently applied.

Policies ensure safer usage of MCP tools by applying filters such as:

• Malicious Instruction Injections – Defends against prompt injection or jailbreak attempts.

• Data Protection – Prevents exposure of sensitive data like PII, credentials, or secrets.

• Security Filters – Defends against MCP tool vulnerabilities such as command injection, path traversal, secrets leakage, and SQL injection.

These registry-level guardrails are enforced after a tool response is received when requests are made using an application key.

Application Graph Tab

• Displays all MCP tools accessed via this application's key.

• Shows tool name, MCP server, number of requests, and last used in a graph format.

• Helps you analyze MCP tool usage patterns and identify high-traffic integrations.

Hitting an MCP Server: DeepWiki Example

You can invoke MCP servers such as DeepWiki through an OpenAI LLM (e.g., GPT-4.1).

Below is an example curl request:

curl --location 'https://api-dev.javelin.live/v1/responses' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer {{OPENAI_SECRET_KEY}}' \
--header 'X-Javelin-Apikey: {{APPLICATION_DEVELOPER_KEY}}' \
--data '{
      "input": "List all tools which are supported in the 2025-03-26 version of the MCP spec.",
      "model": "gpt-4.1",
      "tools": [
        {
          "headers": {
            "Authorization": "Bearer {{APPLICATION_DEVELOPER_KEY}}"
          },
          "require_approval": "never",
          "server_label": "deepwiki",
          "server_url": "https://api-dev.javelin.live/v1/mcp/deepwiki",
          "type": "mcp"
        }
      ]
    }'

• Authorization: Bearer OPENAI_SECRET_KEY → Authenticates with the OpenAI LLM provider.

• X-Javelin-Apikey: APPLICATION_DEVELOPER_KEY → Authenticates the request in Javelin and logs it under the Application.

• tools block → Connects the LLM to the MCP server (here: deepwiki).

  • Authorization (inside tools block): Bearer APPLICATION_DEVELOPER_KEY → Authenticates requests made by the LLM to the MCP server via Javelin Gateway. This ensures the MCP tool invocation is also tracked under the same Application’s Chronicles.

Payload Example

mcp_registry:
  name: "deepwiki"                                # Unique server key
  description: "Deepwiki MCP server"              # Optional description
  type: "streamable-http"                         # MCP server transport/type
  endpoint: "https://mcp.deepwiki.com/mcp"        # MCP server endpoint URL
  is_active: true                                 # Enable/disable the registry
  config:
    authorization_token: "<SECRET_TOKEN>"         # Optional. Token used by MCP server, if needed
  policy:
    dlp:
      enabled: false
      strategy: ""
    prompt_safety:
      enabled: false
      content_types: []
      reject_prompt: ""
    indirect_prompt_safety:
      enabled: false
      content_types: []
      reject_prompt: ""

Chronicles for MCP Requests

Any request made to an MCP server using an Application Developer Key will appear in that Application’s Chronicles tab.

There you can see:

• Input sent in the request

• Output received in the response

• Tool invocations (e.g., DeepWiki calls)

• Guardrail checks

This ensures that all MCP-related activity is auditable under the Application whose key was used.