context-space — Summary

Context Space is a Go-based open-source backend infrastructure project that provides a unified MCP server aggregating OAuth-secured integrations with 14+ external services (GitHub, Slack, Airtable, HubSpot, Notion, Spotify, Stripe, etc.) for AI agents. It positions itself as "the first context engineering infrastructure" — turning the theory of context engineering into production-ready tooling. The system manages credentials via HashiCorp Vault, provides one-click OAuth flows (no JSON config editing), exposes a unified RESTful API at api.context.space, and offers Cursor IDE deep-link installation. Current phase delivers secure credential management and tool aggregation; future phases plan native MCP support, context memory, semantic retrieval, and context optimization.

Compared to seeds: no seed is a hosted MCP aggregator infrastructure project. The closest is ccmemory (MCP tool access for AI agents) but context-space is infrastructure (server backend + credential management) rather than a memory system. Unlike ccmemory which focuses on session memory, context-space focuses on real-time external service integration with enterprise security (HashiCorp Vault, AGPL license transitioning to Apache 2.0).

context-space — Origin & Philosophy

Origin

Created by the context-space organization, 14 contributors, AGPL-3.0 license (transitioning to Apache 2.0). Go-primary codebase. 810 stars. Last commit 2025-10-22.

Mission

"Context Space: The First Context Engineering Infrastructure to 10× Your Productivity"

"Today's AI agents excel at reasoning but terrible at acting in the real world. They're cut off from live data and tools, trapped behind scattered APIs, inconsistent sources, and complex authentication."

Core Value Proposition

Context Space solves three production problems with MCP in enterprise contexts:

1. Manual, Insecure Credential Handling → One-Click OAuth + HashiCorp Vault
2. Inconsistent and Complex APIs → Single unified RESTful API
3. Complex Deployment and Scattered MCP Servers → Unified Context Plane with Tool Aggregation

Philosophy

Context Space frames itself as the bridge from "context engineering theory" to practice:

"Context engineering is the foundation for building reliable AI agents. It goes beyond prompt engineering by managing not only what users say to the model, but also the broader context that shapes its behavior, such as tools, memory, and data."

"MCP defines a standard path for agents to securely access real-world services. Context Space brings that vision to life by turning MCP into production-ready infrastructure."

License Strategy

AGPL-3.0 now (startup protection phase) → Apache 2.0 future (community growth phase). CLA required for contributors to enable this transition.

Roadmap

Phase 1 (Available Now)

Production-ready: OAuth + Vault, unified API, tool aggregation, 14+ integrations

Phase 2 (6-12 months)

Native MCP Support, Context Memory, Smart Aggregation, Semantic Retrieval, Context Optimization

Phase 3 (12+ months)

Context Synthesis, Predictive Loading, AI Context Reasoning

context-space — Architecture

Distribution

• Type: standalone-repo (Go backend server + React web frontend)
• License: AGPL-3.0 (transitioning to Apache 2.0)
• Backend language: Go 1.24
• Storage: PostgreSQL + HashiCorp Vault
• Deploy: Docker + systemd

Install Methods

# Via Claude Code CLI
claude mcp add "context-space" https://api.context.space/api/mcp --header "Authorization: Bearer YOUR_API_KEY"

# Via Cursor IDE deep link (one-click)
# cursor://context-space/<integration>  — no JSON editing

# Self-host (Docker)
docker compose -f backend/docker/docker-compose.yml up

# Get API key at: https://app.context.space/settings

Required Runtime (Self-hosted)

• Go 1.24
• Docker
• PostgreSQL
• HashiCorp Vault

Directory Structure

context-space/
├── backend/
│   ├── cmd/
│   │   ├── server/           # HTTP server entry point
│   │   ├── mcp-tool/         # MCP server binary
│   │   ├── load_providers/   # Integration loader
│   │   └── credentialmanagement/
│   ├── internal/
│   │   ├── credentialmanagement/  # Vault-backed credential storage
│   │   ├── identityaccess/        # Auth/authz
│   │   ├── integration/           # OAuth integration handlers
│   │   ├── provideradapter/       # Service adapters (GitHub, Slack, etc.)
│   │   ├── providercore/          # Provider abstraction
│   │   └── translation/           # API format translation
│   ├── hashivault/           # HashiCorp Vault integration
│   ├── migrations/           # Database migrations
│   └── docker/
├── web/                      # Frontend (unknown stack)
└── docs/

Target AI Tools

• Claude Code (MCP via claude mcp add)
• Cursor IDE (deep links + MCP)
• Any MCP client (hosted endpoint api.context.space/api/mcp)
• Claude Desktop, Windsurf (via mcp.json config)

Hosted Service

Available at:

• MCP endpoint: https://api.context.space/api/mcp
• API: https://api.context.space/v1/
• Web UI: https://app.context.space/
• Integrations browser: https://context.space/integrations

context-space — Components

MCP Server (1)

Single unified MCP server exposing all integrated services as MCP tools.

All 14+ integrations are surfaced as individual MCP tool calls through this single endpoint.

Production-Ready Integrations (14+)

REST API

https://api.context.space/v1/ provides:

• GET /users/me — Authentication check
• POST /credentials/auth/oauth/{service}/auth-url — Get OAuth URL
• POST /invocations/{service}/{operation} — Execute tool operations
• Full Swagger docs at http://api.context.space/v1/docs

Backend Components (Go)

Slash Commands / Skills

None — this is backend infrastructure, not an agent framework.

Hooks

None documented.

Scripts

Makefile targets for lint, tests, Docker builds.

context-space — Uniqueness & Positioning

differs_from_seeds

No seed framework is a hosted MCP aggregator infrastructure project. The closest is ccmemory (MCP-anchored tool access for Claude Code) but ccmemory is a self-hosted memory system while context-space is production infrastructure for real-time external service access. Context-space uses HashiCorp Vault for credential management — an enterprise security primitive not present in any seed. Unlike Nex (which integrates similar external services via cloud KB), context-space exposes them as MCP tools for real-time invocation rather than knowledge graph queries. The Go backend + PostgreSQL + Vault stack is the most "production-grade" technical architecture in this batch.

Positioning

Context-space is uniquely positioned as infrastructure-as-service for MCP — it handles the hardest part of MCP adoption (OAuth credential management, service authentication, API normalization) so AI agents can access real-world services without friction. The AGPL→Apache license transition signals a startup that wants to build community before commercializing.

Observable Failure Modes

• Cloud dependency: All credentials managed by Context Space's cloud infrastructure. Self-hosting requires Go, Docker, and HashiCorp Vault.
• 810 stars, last commit 2025-10: Lower engagement than its positioning implies. The roadmap's Phase 2 (memory, semantic retrieval) is ambitious; delivery is unconfirmed.
• No memory in current release: Despite calling itself "context engineering infrastructure," current Phase 1 has no memory, no retrieval, no context optimization — just OAuth-secured tool aggregation.
• AGPL license risk: Enterprise users may be blocked by AGPL until Apache 2.0 transition occurs.

Cross-References

• Conceptually related to: Nex (also aggregates external services for AI agents)
• More infrastructure-oriented than: contextmcp (similar positioning, no public code)