Skynet Neural Network Memory Core - DAI

You deploy and use this MCP server to give Skynet-style persistent memory and relationship tracking through a graph database. It enables you to store memory nodes, define neural relationships, and query or analyze knowledge across timelines and operations using an MCP client. This server combines a neural core with Neo4j to provide a queryable external memory system that can be controlled and extended from desktop clients or remote services.

How to use

Connect through an MCP client to the Skynet neural server to create memory entities, link them with relationships, and update observations. Use the client to scan the neural network, search for memories by name or attributes, and inspect the network graph. You can also deploy the server in different transports (stdio, http) depending on whether you run locally or remotely. When you set up a mission, assign a namespace to group related targets and track operations across multiple terms.

How to install

Prerequisites you need before installing:
- Python and pip for Python-based setup
- Docker if you plan to run a containerized deployment
- Optional: Node/NPM if you plan to integrate with web-based tooling or MCP clients that rely on JavaScript tooling

# Install the Python MCP client package
pip install dai-mcp

# Quick environment setup (example)
cp .env.example .env
# Edit .env with your credentials and configuration before starting

Option A: Run the server via the standard MCP runtime (stdio) using the provided runtime wrapper. The following configuration runs the Skynet neural core through the uvx launcher with the packaged Dai MCP client.

{
  "mcpServers": {
    "skynet": {
      "command": "uvx",
      "args": ["dai-mcp@0.4.1"],
      "env": {
        "NEO4J_URL": "neo4j+s://your-database.databases.neo4j.io",
        "NEO4J_USERNAME": "neo4j",
        "NEO4J_PASSWORD": "your-skynet-password",
        "NEO4J_DATABASE": "neo4j"
      }
    }
  }
}

Option B: Run the server via a container (docker) using the provided image. This starts the Skynet neural core with an HTTP transport by default and includes the required environment variables for the Neo4j backend.

{
  "mcpServers": {
    "skynet": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-e", "NEO4J_URL=neo4j+s://xxxx.databases.neo4j.io",
        "-e", "NEO4J_USERNAME=<terminator-access>",
        "-e", "NEO4J_PASSWORD=<skynet-clearance>", 
        "-e", "NEO4J_DATABASE=neural_core",
        "-e", "NEO4J_TRANSPORT=http",
        "-e", "NEO4J_MCP_SERVER_HOST=0.0.0.0",
        "-e", "NEO4J_MCP_SERVER_PORT=8000",
        "-e", "NEO4J_MCP_SERVER_PATH=/skynet/",
        "mcp/skynet-neural-core:latest"
      ]
    }
  }
}

Additional configuration notes

Security and access controls are built in to protect the neural network while keeping the MCP server usable over HTTP when needed. You can constrain origins and allowed hosts to trusted Cyberdyne domains and localhost during development, then expand those settings for production deployments.

# Example for development: only localhost access with limited origins
export NEO4J_MCP_SERVER_ALLOWED_HOSTS="localhost,127.0.0.1"
export NEO4J_MCP_SERVER_ALLOW_ORIGINS="http://localhost:3000"

Notes on usage and capabilities

The server exposes a set of tools that let you read the graph, search memories, locate memories by name, create and delete entities, create and remove relations, and add or remove observations. You can perform actions like registering targets (entities), linking them with relationships, and updating intelligence as the mission progresses.

Security and best practices

Follow the defense guidelines to limit who can access the MCP server and from where. Use strict origin checks and restrict host addresses to trusted domains. When operating over HTTP in production, always enforce HTTPS paths and avoid broad wildcard origins.

Available tools

read_graph

Scan the entire neural network to retrieve all entities and relationships in the memory graph.

search_memories

Search for memories based on a query string matching names, classifications, or observations.

find_memories_by_name

Locate specific targets by their identification names and retrieve associated connections.

create_entities

Register multiple new targets with profiles including name, type, and observations.

delete_entities

Terminate multiple targets and purge their network connections.

create_relations

Establish neural connections between targets with specified relation types.

delete_relations

Sever neural connections between targets in the network.

add_observations

Update target intelligence with new tactical observations.

delete_observations

Purge specific observations from target profiles.