DEV Community: Contextum

Building a Remote MCP Server on Contextum (Without Auth)

Contextum — Tue, 20 May 2025 06:18:40 +0000

As AI and Web3 ecosystems continue to evolve, developers face the challenge of building scalable, flexible, and secure infrastructure for their applications. One such solution is deploying Model Context Protocol (MCP) servers that can manage context data for AI models or agents. Contextum offers a simple, serverless way to deploy remote MCP servers without the hassle of authentication, so you can focus on building and testing your AI and Web3 applications quickly.

This article will guide you through the process of setting up a remote MCP server on Contextum, why it’s a great tool for rapid development, and how to easily connect it to the Contextum Playground or local clients.

Why You Should Build a Remote MCP Server on Contextum

When building AI systems, managing context data and enabling easy interaction with various tools is crucial. However, setting up traditional servers or managing complex authentication mechanisms often adds unnecessary overhead. Here’s why using Contextum for deploying a remote MCP server without authentication is a compelling choice:

Zero Authentication Overhead: Authentication systems can significantly complicate development workflows, especially in early stages or prototypes. Contextum removes this complexity by allowing you to deploy an MCP server that doesn’t require managing user identities or tokens.
Frictionless Integration: With Contextum, you can deploy your MCP server and connect it to the Contextum Playground or local clients in minutes, giving you a quick feedback loop for testing and iterating on your AI models.
Highly Extendable: Contextum is designed to be flexible. You can easily add custom tools to the MCP server, integrate your own models, and extend the server's functionality as your project grows.
Web3 Compatibility: Contextum is ideal for decentralized AI projects. The serverless nature of the platform combined with decentralized tools makes it perfect for Web3 applications that need to manage AI context data in a distributed, scalable manner.

Now, let’s dive into how to set up and deploy a remote MCP server on Contextum.

Step-by-Step Guide to Building Your Remote MCP Server on Contextum

Step 1: Initialize Your Project

Start by creating a new Contextum project that includes a template for a remote MCP server without authentication. This template comes pre-configured with basic tools that you can modify and extend based on your needs.

Run the following command to create a new Contextum project:

npm create contextum@latest -- my-mcp-server --template=contextum/ai/demos/remote-mcp-authless

This command will scaffold a new project for you in the my-mcp-server directory. Once the project is created, navigate into the project directory and install the dependencies:

cd my-mcp-server
npm install

Step 2: Customize Your MCP Server

In the src/index.ts file, you can define and customize the tools that your server will provide. Here is an example of adding two tools: a simple calculator and a multiplier.

import { MCPServer } from "contextum-server";

class MyMCPServer extends MCPServer {
  init() {
    // Tool to add two numbers
    this.server.tool("calculator", (input) => {
      return {
        result: input.number1 + input.number2
      };
    });

    // Tool to multiply two numbers
    this.server.tool("multiplier", (input) => {
      return {
        result: input.number1 * input.number2
      };
    });

    // Tool to divide two numbers
    this.server.tool("divider", (input) => {
      if (input.number2 === 0) {
        return { error: "Cannot divide by zero!" };
      }
      return { result: input.number1 / input.number2 };
    });
  }
}

export default new MyMCPServer();

In this example, we define three tools:

calculator: Adds number1 and number2 from the input.
multiplier: Multiplies number1 and number2.
divider: Divides number1 by number2, with an error check for division by zero.

These tools are defined using this.server.tool(...) and can be accessed via the MCP server once it’s deployed.

Step 3: Deploy Your MCP Server to Contextum

After configuring your server, deploy it to Contextum. The deployment process is straightforward, and the Contextum CLI handles all the infrastructure management for you.

To deploy your server, simply run:

npm run deploy

After deployment, your server will be available at a URL like:

https://<your-project-name>.app.contextum.org/sse

This is the endpoint you’ll use to interact with your server, either from the Contextum Playground or local clients.

Step 4: Connect Your MCP Server to the Contextum Playground

The Contextum Playground is an interactive, web-based environment for testing and experimenting with your MCP server. To connect to your deployed server, follow these steps:

Visit the Contextum AI Playground at https://playground.contextum.org/.
Enter the URL of your deployed server: https://<your-project-name>.app.contextum.org/sse.

Once connected, you can interact with the tools you’ve defined (like calculator, multiplier, and divider) directly in the Playground. This makes it easy to test the server's behavior in real time.

Step 5: Connect Your MCP Server to Local Clients

You can also connect your remote MCP server to local clients using the mcp-remote proxy. This allows you to send requests to your remote server from tools like Claude Desktop.

To connect Claude Desktop to your MCP server, follow these steps:

Open Claude Desktop.
Go to Settings > Developer > Edit Config.
Add the following configuration for your MCP server:

{
  "mcpServers": {
    "calculator": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://<your-project-name>.app.contextum.org/sse"
      ]
    }
  }
}

This configuration tells Claude Desktop to route its MCP requests through your remote server. Once you restart the application, you should see your defined tools available for use.

Advantages of Using Contextum for Remote MCP Servers

No Authentication Hassles: Traditional authentication systems can be time-consuming to set up and manage. By using Contextum’s authentication-free server, you can bypass all the extra work and focus on building your application.
Rapid Deployment: With Contextum, deploying your server is as simple as running a single command. You don’t have to manage infrastructure, allowing you to focus on the tools and functionality you want to offer.
Seamless Integration: Whether you’re using the Contextum Playground for interactive testing or connecting to local tools like Claude Desktop, Contextum makes integration smooth and effortless.
Extendable and Scalable: Add any custom tools you need to extend the functionality of your MCP server. Whether it’s building new AI models or integrating third-party tools, Contextum supports all your needs as your project grows.
Ideal for Web3: The serverless, decentralized nature of Contextum makes it a perfect fit for Web3 applications where decentralized context management is a key component.

Official Links for Contextum:

This setup empowers developers to build and deploy remote MCP servers quickly, test them interactively, and integrate them with various AI tools without having to deal with complex authentication systems or infrastructure management.

This version should be ready for dev.to with added Contextum links for further engagement!

Streamlining Decentralized Infrastructure with the Contextum CLI

Contextum — Sun, 18 May 2025 21:49:52 +0000

Contextum's Modular Compute Protocol (MCP) introduces a new paradigm for decentralized, modular compute infrastructure. While its core architecture is powerful on its own, the Contextum CLI is the tool that brings it all together for developers and operators. In this article, we explore the technical details of how this CLI empowers professionals to deploy, manage, and monitor MCP deployments efficiently.

What is Contextum CLI?

The Contextum CLI (ctxctl) is a command-line tool designed to interact with the MCP stack. It provides fine-grained control over deployment lifecycle operations including cluster initialization, node provisioning, configuration updates, monitoring, and teardown.

1. Deployment Management

The CLI abstracts low-level orchestration complexity. Under the hood, it wraps tools like Terraform and Ansible (or native equivalents) to provision infrastructure and bootstrap MCP nodes across global regions.

ctxctl init --name dev-cluster --region us-east --nodes 3
ctxctl deploy --config config.yaml

Supports:

Cloud and bare-metal provisioning
Multi-region deployment strategies
AI module pinning per node

2. Configuration as Code

ctxctl supports declarative configurations via YAML. This makes infrastructure reproducible and auditable.

`yaml

config.yaml

nodes:
count: 5
type: edge
region: eu-central
ai_modules:

name: langchain-agent version: latest `

This configuration is parsed by the CLI and translated into infrastructure provisioning steps.

3. Versioned Upgrades

Keeping nodes and modules in sync is critical in modular compute environments. The CLI supports rolling updates, zero-downtime deployments, and module pinning.

bash ctxctl update --deployment dev-cluster --version 2.1.4

4. Observability and Debugging

Integrated observability features:

bash ctxctl status --deployment dev-cluster ctxctl logs --node node-1 --follow

Data is pulled from MCP internal APIs and logs via gRPC endpoints, allowing efficient real-time monitoring.

5. Secure Identity and Access

Supports identity primitives like ed25519 and PQC keys. Credential management can be integrated with vault systems.

TLS mutual auth
Role-based permissions
Encrypted deployment configs

Internals

The CLI is built in Rust for performance and safety. It uses:

clap for argument parsing
serde for configuration parsing
reqwest and tonic for HTTP/gRPC communication

It interfaces with the MCP Control Plane over authenticated channels and caches metadata in local state directories (~/.contextum/).

For developers building on Contextum MCP, the CLI is more than just a tool — it's the operational backbone. By abstracting complexity while exposing fine-grained control, it enables rapid and reliable infrastructure deployment and management. If you're looking to scale decentralized compute or deploy AI at the edge, ctxctl is a core part of the workflow.

Try it: curl -s https://install.contextum.sh | bash

🔗 Contextum Links

🌐 Website: https://contextum.org
🧠 GitHub: ContextumAI
🐦 Twitter/X: @contextumai

Follow for more deep dives into Contextum tooling and architecture.

ContextumAI: Secure, On-Chain MCP Server Deployment for Decentralized AI

Contextum — Sat, 17 May 2025 20:34:22 +0000

As AI systems move toward agentic architectures and autonomous collaboration, the demand for context-aware inference in decentralized settings is growing. But today, deploying and governing Model Context Protocol (MCP) servers across EVM networks is still too fragile, insecure, and manual.

ContextumAI provides a decentralized, cryptographically verifiable platform to securely deploy and manage MCP servers with on-chain permissioning and tokenized governance.

This post goes deep into the architecture, tooling, and smart contract mechanics of Contextum.

Problem Landscape: Why MCP Servers Need Better Infrastructure

Model Context Protocol (MCP) servers are designed to serve real-time contextual data to AI agents—embeddings, metadata, model prompts, inference state—across trustless environments. However, current approaches have critical flaws:

1. Lack of Deployment Standardization

MCP server deployments are typically hand-crafted or glued together with ad hoc scripts. These environments differ widely, introducing inconsistencies and misconfigurations.

2. No On-Chain Verifiability

There’s no way for an agent to verify that a specific context server is running a particular container image or was deployed by a trusted identity.

3. No Governance or Access Control

Permissions to deploy, upgrade, or terminate context servers are often centralized and untraceable.

Contextum’s Architecture: Layered Security Meets Developer Usability

Core Design Goals:

Immutable + verifiable deployment
On-chain governance for upgrades and access
Portable CLI tooling
Modular server runtimes

1. Containerized MCP Runtimes

Our MCP server is a stateless containerized application written in TypeScript and powered by Bun, selected for fast startup, native TS support, and small binary footprint.

Example stack:

Runtime: Bun 1.x
Container: Alpine Linux + Docker BuildKit
Security: seccomp, no root, read-only FS, AppArmor

Sample Dockerfile:

FROM oven/bun:alpine

WORKDIR /app
COPY . .

RUN bun install --production

CMD ["bun", "start"]

We restrict permissions aggressively—disabling shell access, limiting filesystem writes, and isolating secrets via environment variables passed only at runtime.

2. CLI Tooling (`contextum-cli`)

To reduce friction and error-proneness, we’ve built a CLI tool that abstracts complex steps into verifiable workflows:

bash npx contextum-cli init npx contextum-cli build npx contextum-cli deploy --network sepolia --image-hash Qm123... --sign

CLI Features:

Local container test & sign
Push to decentralized registry (Phase 2)
Deploy via smart contracts
Track deployments by wallet address
Typed config schema (contextum.config.ts)

Internally, we use dockerode for container handling and ethers.js for chain interaction.

3. Smart Contracts

We’ve deployed minimal, auditable contracts to Ethereum testnet (currently Sepolia).

`ImageRegistry.sol`

Stores SHA-256 hashes of verified container images:

solidity function registerImage(bytes32 hash) external onlyStaker { require(!registered[hash], "Already registered"); registered[hash] = true; emit ImageRegistered(hash, msg.sender); }

`MCPDeploymentManager.sol`

Tracks deployment metadata:

Deployer address
Image hash
Deployment timestamp
Linked governance settings

Deployments are signed client-side and validated on-chain.

4. Governance Layer (CTXM Token)

CTXM is our native ERC-20 token that governs protocol-level permissions.

CTXM Utility:

Stake to deploy servers (anti-spam)
Vote on protocol upgrades
Access premium server templates
Fee discounts for enterprise deployments

Deployment Pipeline (Under the Hood)

Sample flow:

Developer signs container image (SHA-256)
CLI uploads hash to ImageRegistry
CLI deploys MCP server
Metadata committed to MCPDeploymentManager
Smart contract emits DeploymentRegistered
Agents verify the deployment via chain

Roadmap

Phase	Goal
✅ Phase 1	MVP CLI, secure runtime, Sepolia testnet
⏳ Phase 2	Decentralized image registry, encrypted secrets
🔜 Phase 3	DAO governance launch, Snapshot voting, staking UI
⏭ Phase 4	IPFS log persistence, zk proof-of-context, enterprise integrations

Dev Resources

Playground: https://app.contextum.org
GitHub: https://github.com/ContextumAI
- contextum-cli
- mcp-runtime
- smart-contracts

Final Thoughts

We believe the future of AI is decentralized—and context is the missing layer. Contextum bridges Web3 infrastructure with verifiable AI serving for autonomous agents.

If you’re interested in:

Running an MCP node
Contributing to contracts
Integrating decentralized governance

We’d love to hear from you.

Contact: founders@contextum.org
Website: https://contextum.org