Wake Intelligence

Wake Intelligence MCP provides a production-ready server that implements a 3-layer temporal intelligence brain. It learns from the past, manages the present, and anticipates future needs to optimize context retrieval, memory management, and pre-fetching for AI-driven workflows. This enables explainable decisions, efficient memory use, and proactive data access for AI agents and projects that rely on semantic context.

How to use

You connect to the MCP server from an MCP client to access context management, causality tracing, memory organization, and predictive provisioning. You can run the server locally for development or deploy it to a hosting environment, then integrate it with clients like Cloudflare AI Playground or Claude Desktop using the provided connection configurations. The architecture exposes three capabilities: reconstructing why contexts exist (Past), managing how contexts are used right now (Present), and predicting what contexts will be needed next (Future). Start by ensuring your MCP server is reachable at a URL or accessible via an inline command, then configure your client to point at that endpoint.

To use the remote MCP workflow with a Cloudflare-enabled environment, your client will connect to the MCP endpoint that serves the SSE stream and protocol for tool orchestration. You can also connect a local client like Claude Desktop by running a small proxy that exposes the MCP server locally and then pointing the client at that proxy. The three layers work together to deliver fast access to relevant contexts, explainable decisions, and proactive data preparation.

For quick testing during development, you can begin by running the development server, then verify that you can store, load, and search for contexts, and finally check that the system can suggest high-value contexts to pre-fetch. The architecture is designed to be observable and explainable, so you can inspect why a context was created, how it is being accessed, and why a particular context is prioritized for future usage.

How to install

Prerequisites you need before installing include Node.js 20.x or higher and a runtime environment for your chosen hosting approach. If you plan to deploy with Cloudflare Workers, you will also use Wrangler to manage a D1 database for persistent context storage.

Step-by-step installation flow you can follow exactly: separate commands into their own lines.

1. Install the needed tooling and dependencies.

# Install Wrangler globally for Cloudflare Workers development
npm install -g wrangler

# Install project dependencies
npm install

2. Prepare the environment and database.

# Create a Cloudflare D1 database for the MCP context
wrangler d1 create mcp-context

# Update wrangler.jsonc with your database ID as shown by the create command
# Example: replace YOUR_DATABASE_ID with the actual ID

3. Run local migrations and start the development server.

# Local development migration
wrangler d1 execute mcp-context --local --file=./migrations/0001_initial_schema.sql

# Start the development server
npm run dev

4. Deploy to production when ready.

npm run deploy

Your MCP server will be available at a URL formatted for your account, for example: semantic-wake-intelligence-mcp.your-account.workers.dev

Configuration and connection options

You can connect client tools to your MCP server using two common approaches: a remote HTTP endpoint or a local stdio-based proxy command. The remote endpoint is suitable for cloud-hosted access, while the stdio approach is convenient for local development and client integrations that invoke the MCP server directly.

Connect to a local stdio proxy from an MCP client by using the following command configuration. This enables you to run the MCP server through a lightweight proxy and point your client to the local address.

{
  "mcpServers": {
    "semantic_context": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://localhost:8787/sse"  // or semantic-wake-intelligence-mcp.your-account.workers.dev/sse
      ]
    }
  }
}

If you prefer a remote HTTP endpoint, you can point your client at the server’s SSE URL directly. The HTTP configuration would look like this when you provide the remote URL.

{
  "type": "http",
  "name": "semantic_context_http",
  "url": "https://remote-mcp-server-authless.your-account.workers.dev/sse",
  "args": []
}

Security and best practices

Treat the MCP server as a trusted integration point. Use secure channels (HTTPS) for remote endpoints, rotate credentials for any tokens or keys used by clients, and validate inputs at the client edge before transmitting to the MCP server. Review access controls and ensure that D1-based persistence is secured behind appropriate Cloudflare permissions.

Troubleshooting and notes

If you encounter connectivity issues, verify that the MCP server is running, the endpoint URL is correct, and the SSE path matches what your client expects. For local development, confirm that the migrations completed successfully and that the D1 database binding is accessible with the configured database name and binding.

Database setup

The server uses a Cloudflare D1 database for persistent context storage. Create and initialize the database, then apply the initial schema migration to establish tables and semantic indexes used by the MCP.

Examples of core capabilities

Key operations you can perform through clients include saving and loading contexts, searching contexts, reconstructing causality, managing memory tiers, pruning expired contexts, updating predictions, and retrieving high-value contexts for proactive access.

Notes on architecture

The implementation follows a domain-driven hexagonal structure. The domain layer contains business logic for contexts, the application layer orchestrates operations, the infrastructure layer provides technical adapters (D1 persistence and AI integrations), and the presentation layer handles HTTP routing for MCP interactions. This organization supports testability, maintainability, and clear semantic intent across all components.

Tools and endpoints

The MCP server exposes capabilities such as saving and retrieving contexts, causality reasoning, memory tier management, and future propagation predictions. Each tool is designed to be observable and explainable, with clear semantics tied to past, present, and future layers.

License

This project is released under the MIT License, providing permissive terms for use, modification, and distribution.

Available tools

save_context

Save a conversation context with AI-powered summarization and auto-tagging.

load_context

Retrieve relevant context for a project using Layer 2 memory tracking.

search_context

Search contexts by keyword with access tracking.

reconstruct_reasoning

Explain WHY a context was created by reconstructing its reasoning.

build_causal_chain

Trace decision history backwards through time to reveal dependencies.

get_memory_stats

Provide statistics on memory tier distribution and usage.

recalculate_memory_tiers

Reevaluate and update memory tier classifications based on current time.

prune_expired_contexts

Automatically remove contexts that have expired.

update_predictions

Refresh prediction scores for a project.

get_high_value_contexts

Retrieve contexts most likely to be accessed next.

get_propagation_stats

Analytics on prediction quality and usage patterns.