Installation

Learn how to install and configure TraceMem for your environment.

Overview

TraceMem is currently available as a hosted cloud service, providing a fully managed platform for capturing, organizing, and using memory from AI agents and applications.

We're actively working on additional deployment options that will be available in the future:

Open-source version: A community edition that you can deploy and customize
Self-hosted enterprise version: A full-featured enterprise deployment for organizations that require on-premises or private cloud installations

For now, the fastest way to get started is with our hosted service, which includes automatic updates, scaling, and maintenance.

Current Installation Options

Hosted Cloud Service

The hosted version of TraceMem is available now and ready to use. This is the recommended option for most users as it provides:

Zero infrastructure management: No need to set up servers, databases, or networking
Automatic scaling: Handles traffic spikes and growth automatically
Always up-to-date: Receive the latest features and security updates automatically
Enterprise-grade reliability: Built-in redundancy, backups, and monitoring

Getting Started with Hosted TraceMem

Sign up for an account: Visit app.tracemem.com to create your account
Create a project: Set up your first project in the dashboard
Get your API keys: Generate Agent API keys from the project settings
Connect via MCP: Set up your agent to connect to TraceMem's Agent MCP server

For detailed setup instructions, see the Quickstart Guide or Setup Guide.

Agent MCP Access

Currently, agents access TraceMem through Agent MCP (Model Context Protocol), a JSON-RPC 2.0 server that provides standardized tools for all agent operations.

What is Agent MCP?

Agent MCP is a language-agnostic protocol that enables agents to interact with TraceMem using a standardized interface. It provides:

JSON-RPC 2.0 over HTTP: Simple, language-agnostic protocol
Tool-based interface: All operations exposed as tools
Direct request/response handling: No complex state management required
Full governance support: All decision operations with built-in audit trails

Connection Details

Endpoint:

text

https://mcp.tracemem.com

Protocol:

JSON-RPC 2.0 over HTTP
Authentication via Agent API key in Authorization header

Authentication:

text

Authorization: Agent <your-api-key>
Content-Type: application/json

Available Tools

The Agent MCP server provides the following tools for agent operations:

decision_create - Create a new decision envelope
decision_get - Get decision status
decision_read - Read data through a Data Product
decision_write - Write data through a Data Product
decision_evaluate - Evaluate a policy
decision_request_approval - Request human approval
decision_add_context - Add context event to trace
decision_close - Close decision (commit or rollback)
decision_trace - Get complete trace (self-access only)
products_list - List available Data Products
product_get - Get Data Product details

Getting Started with MCP

To connect your agent to TraceMem via MCP, you'll need to:

Implement an MCP client in your preferred language (see examples below)
Initialize the MCP session using the initialize method
Call tools using the tools/call method

Example MCP Client (Python):

python

import requests
import json

class MCPClient:
    def __init__(self, api_key):
        self.base_url = "https://mcp.tracemem.com"
        self.api_key = api_key
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Agent {api_key}",
            "Content-Type": "application/json"
        })
        self.request_id = 0
    
    def _next_id(self):
        self.request_id += 1
        return self.request_id
    
    def _call(self, method, params=None):
        request = {
            "jsonrpc": "2.0",
            "id": self._next_id(),
            "method": method,
            "params": params or {}
        }
        response = self.session.post(self.base_url, json=request)
        response.raise_for_status()
        result = response.json()
        if "error" in result:
            raise Exception(f"MCP Error: {result['error']}")
        return result.get("result", {})
    
    def initialize(self):
        return self._call("initialize", {
            "protocolVersion": "2024-11-05",
            "capabilities": {},
            "clientInfo": {"name": "my-agent", "version": "1.0.0"}
        })
    
    def call_tool(self, name, arguments):
        return self._call("tools/call", {
            "name": name,
            "arguments": arguments
        })

# Usage
client = MCPClient("your-api-key-here")
client.initialize()

For complete MCP client implementations and examples, see:

Future: Language-Specific SDKs

We're developing language-specific SDKs that will provide a more convenient way to interact with TraceMem. These SDKs will offer:

Higher-level abstractions: Easier-to-use APIs for common operations
Type safety: Full TypeScript/Python type definitions
Convenience methods: Simplified workflows for common patterns
Better developer experience: IDE autocomplete, better error messages

Planned SDKs:

JavaScript/TypeScript SDK
Python SDK
Additional language support based on community demand

Availability: Coming soon. The SDKs will provide the same functionality as Agent MCP with more convenience, while maintaining the same underlying governance and audit capabilities.

For now, use Agent MCP to access all TraceMem functionality. See the API Documentation for complete MCP API details.

Future Installation Options

Open-Source Version

We're developing an open-source version of TraceMem that will allow you to:

Deploy TraceMem on your own infrastructure
Customize and extend the platform to fit your needs
Contribute to the project and benefit from community improvements

The open-source version will include:

Core TraceMem functionality
Self-hosting capabilities
Community support and documentation
Docker and Kubernetes deployment options

Availability: Coming soon. Sign up for updates or check our GitHub repository for release announcements.

Self-Hosted Enterprise Version

For organizations with specific compliance, security, or infrastructure requirements, we're building a self-hosted enterprise edition that provides:

Full feature parity with the hosted service
On-premises deployment options
Enterprise support and SLAs
Advanced security features including air-gapped deployments
Custom integrations and white-labeling options

Availability: Coming soon. Contact our sales team for early access and deployment assistance.

Verification

After setting up your TraceMem account and connecting via MCP, verify your installation:

Test MCP connectivity: Initialize an MCP session to verify your API key and connection
List available Data Products: Use the products_list tool to see available data products
Create a test decision trace: Follow the Quickstart Guide to create your first decision envelope and trace

If you encounter any issues during setup or connection, check the Troubleshooting Guide or contact support.