MemMachine

https://docs.memmachine.ai
Admin
MemMachine is an open-source memory layer for advanced AI agents that learns, stores, and recalls...
Tokens:152,750
Snippets:1,242
Trust Score:7.3
Update:6 months ago
Show doc for...
Tokens:
Raw
### Setup NLTK Dependencies

Source: https://docs.memmachine.ai/install_guide/install_guide

Run this command after installation to configure necessary NLTK data.

```sh
memmachine-nltk-setup
```

--------------------------------

### MCP Server Setup and SSE Connection

Source: https://docs.memmachine.ai/examples/mcp

Instructions on how to start the MCP server and establish an SSE connection to obtain a session ID.

```APIDOC
## MCP Server Setup

First, ensure your stand alone MCP server is up and running. You can use this sample command to start it:

```bash
MEMORY_CONFIG=config.yml uv run memmachine-mcp-http --host localhost --port 8080
```

In which `config.yml` is your MemMachine configuration file. `localhost` and `8080` are the host and port where the MCP server will listen for requests.

## Establish SSE connection and get session ID

We need a session id to work with the MCP server. We can obtain one by establishing a Server-Sent Events (SSE) connection.

### Method
GET

### Endpoint
`http://localhost:8080/mcp/`

### Headers
- `Accept`: `text/event-stream`

### Request Example
```bash
curl -v -N http://localhost:8080/mcp/ -H "Accept: text/event-stream"
```

### Response Example (Success)
```
* Host localhost:8080 was resolved.
* IPv6: ::1
* IPv4: 127.0.0.1
*   Trying [::1]:8080...
* connect to ::1 port 8080 from ::1 port 62212 failed: Connection refused
*   Trying 127.0.0.1:8080...
* Connected to localhost (127.0.0.1) port 8080
> GET /mcp/ HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/8.7.1
> Accept: text/event-stream
>
* Request completely sent off
< HTTP/1.1 400 Bad Request
< date: Fri, 31 Oct 2025 21:58:56 GMT
< server: uvicorn
< content-type: application/json
< mcp-session-id: 8f82399b29ba42d495ff44d5a9cf7862
< content-length: 105
>
{"jsonrpc":"2.0","id":"server-error","error":{"code":-32600,"message":"Bad Request: Missing session ID"}}
```

**Note**: In the response, look for the `mcp-session-id` header to get the session ID.
```

--------------------------------

### MemMachineClient Usage Example

Source: https://docs.memmachine.ai/api_reference/ts-rest/classes/MemMachineClient

Example demonstrating how to initialize the client and use its methods.

```APIDOC
## Usage Example

The following example demonstrates the recommended pattern for initializing the client and traversing to a specific project and memory instance.

```typescript
import MemMachineClient from '@memmachine/client';

async function main() {
  // 1. Initialize the client
  const client = new MemMachineClient({
    api_key: 'your_api_key'
  });

  // 2. Access a specific project
  const project = client.project({
    org_id: 'your_org_id',
    project_id: 'your_project_id'
  });

  // 3. Initialize memory for that project
  const memory = project.memory();

  // 4. Perform high-level health checks
  const status = await client.healthCheck();
  console.log(`Server Status: ${status.status}`);
}

main();
```

<Tip> For best performance, reuse a single `MemMachineClient` instance across your application to leverage connection pooling through the internal `AxiosInstance`. </Tip>
```

--------------------------------

### Install LangChain and MemMachine Client

Source: https://docs.memmachine.ai/install_guide/integrate/LangChain

Install the necessary libraries for LangChain and the MemMachine client using pip.

```bash
pip install langchain memmachine-client
```

--------------------------------

### Usage Example

Source: https://docs.memmachine.ai/api_reference/ts-rest/classes/MemMachineProject

Example demonstrating how to use the MemMachineProject class.

```APIDOC
## Usage Example

```typescript
const project = client.project({ org_id: 'org_123', project_id: 'proj_456' });

// 1. Create the project if it doesn't exist
await project.create({ description: 'AI Assistant Context' });

// 2. Check the memory footprint
const count = await project.getEpisodicCount();
console.log(`Current memory count: ${count}`);

// 3. Access memory operations
const memory = project.memory();
```

**Note**: This class is the recommended gateway for memory management. Always use `project.memory()` to ensure your operations are correctly scoped to your organization and project ID.
```

--------------------------------

### Install MemMachine SDK

Source: https://docs.memmachine.ai/api_reference/ts-rest/typescript

Install the MemMachine SDK using npm. This is the first step to integrating memory into your application.

```bash
npm install @memmachine/sdk
```

--------------------------------

### Install MemMachine Client with ADK Support

Source: https://docs.memmachine.ai/install_guide/integrate/Google_ADK

Install the client library with the necessary dependencies for Google ADK integration.

```bash
pip install "memmachine-client[google-adk]"
```

--------------------------------

### Download and Install MemMachine Server

Source: https://docs.memmachine.ai/getting_started/quickstart

Platform-specific scripts to download the latest release and initiate the installation process.

```bash
# Download the latest MemMachine release tarball
TARBALL_URL=$(curl -s https://api.github.com/repos/MemMachine/MemMachine/releases/latest \
  | grep '"tarball_url"' \
  | head -n 1 \
  | sed -E 's/.*"tarball_url": "(.*)",/\1/')

curl -L "$TARBALL_URL" -o MemMachine-latest.tar.gz

# Extract the release archive
tar -xzf MemMachine-latest.tar.gz

# Move into the extracted directory (GitHub adds a commit hash to the folder name)
cd MemMachine-MemMachine-*/

# Start the MemMachine installation
./memmachine-compose.sh
```

```powershell
$latestRelease = Invoke-RestMethod -Uri "https://api.github.com/repos/MemMachine/MemMachine/releases/latest"; `
$tarballUrl = $latestRelease.tarball_url; `
$destination = "MemMachine"; `
if (Test-Path $destination) { Remove-Item $destination -Recurse -Force }; `
New-Item -ItemType Directory -Force -Path $destination; `
Invoke-WebRequest -Uri $tarballUrl -OutFile "MemMachine-latest.tar.gz"; `
tar -xzf "MemMachine-latest.tar.gz" -C $destination --strip-components=1; `
Set-Location $destination; `
./memmachine-compose.sh
```

--------------------------------

### Select Ollama Provider During Installation

Source: https://docs.memmachine.ai/install_guide/config/ollama

When prompted by the MemMachine installation script, enter 'Ollama' to configure it to use your local Ollama instance.

```bash
[PROMPT] Which provider would you like to use? (OpenAI/Bedrock/Ollama) [OpenAI]: Ollama
[INFO] Selected provider: OLLAMA
```

--------------------------------

### Install MemMachine and LlamaIndex dependencies

Source: https://docs.memmachine.ai/install_guide/integrate/LlamaIndex

Install the core LlamaIndex framework and the updated MemMachine client.

```bash
pip install llama-index memmachine-client
```

--------------------------------

### Start MemMachine server

Source: https://docs.memmachine.ai/install_guide/configure_wizard

Launch the server using the configuration file generated by the wizard.

```bash
memmachine-server
```

--------------------------------

### Install MemMachine via Pip

Source: https://docs.memmachine.ai/install_guide/install_guide

Install the server package for either CPU-only or GPU-accelerated environments.

```sh
pip install memmachine-server
```

```sh
pip install memmachine-server[gpu]
```

--------------------------------

### Install CrewAI and MemMachine Client

Source: https://docs.memmachine.ai/install_guide/integrate/crewai

Install the core CrewAI framework and the MemMachine client using pip. Ensure you have crewai-tools installed for agent functionality.

```bash
pip install crewai crewai-tools memmachine-client
```

--------------------------------

### Start MemMachine with Compose Script

Source: https://docs.memmachine.ai/install_guide/integrate/claude_code_mcp

Alternatively, use the provided script to start MemMachine if you are not using Docker directly.

```bash
./memmachine-compose.sh
```

--------------------------------

### Install MemMachine Python Client

Source: https://docs.memmachine.ai/api_reference/python/client

Install the client package using pip. This is the primary method for integrating the SDK into your Python project.

```bash
pip install memmachine-client
```

--------------------------------

### Select Bedrock Provider During Installation

Source: https://docs.memmachine.ai/install_guide/config/aws_bedrock

When prompted during installation, select 'Bedrock' to integrate with AWS Bedrock. This sets up the LLM provider for MemMachine.

```bash
[PROMPT] Which provider would you like to use? (OpenAI/Bedrock/Ollama) [OpenAI]: Bedrock
[INFO] Selected provider: BEDROCK
```

--------------------------------

### MemoryContext Usage Example

Source: https://docs.memmachine.ai/api_reference/ts-rest/interfaces/MemoryContext

Example demonstrating how to define and use a MemoryContext object.

```APIDOC
## MemoryContext Usage Example

```typescript
import { MemoryContext } from '@memmachine/client';

const userSession: MemoryContext = {
  user_id: 'user_99',
  session_id: 'chat_hash_abc123'
};
```
```

--------------------------------

### Install MemMachine Python Package

Source: https://docs.memmachine.ai/examples/python

Install the MemMachine Python package using pip. This is the first step to using the SDK.

```bash
pip install memmachine-server
```

--------------------------------

### Install OpenClaw MemMachine Plugin (CLI)

Source: https://docs.memmachine.ai/install_guide/integrate/openclaw

Use the OpenClaw CLI to install the latest stable version of the MemMachine plugin from the registry.

```bash
openclaw plugins install @memmachine/openclaw-memmachine
```

--------------------------------

### Initialization Response

Source: https://docs.memmachine.ai/examples/mcp

Example JSON response confirming successful session initialization.

```json
event: message
data:
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "protocolVersion": "2024-11-05",
    "capabilities": {
      "experimental": {},
      "prompts": {
        "listChanged": true
      },
      "resources": {
        "subscribe": false,
        "listChanged": true
      },
      "tools": {
        "listChanged": true
      }
    },
    "serverInfo": {
      "name": "MemMachine",
      "version": "1.16.0"
    }
  }
}
```

--------------------------------

### Install MemMachine Helm Chart

Source: https://docs.memmachine.ai/install_guide/cloud_deploy/Helm_Chart

Install the MemMachine Helm chart with your OpenAI API key. This command deploys MemMachine with default in-cluster databases.

```bash
helm upgrade --install memmachine . \
  --namespace memmachine \
  --set memmachine.openaiApiKey=sk-xxxx...
```

--------------------------------

### Install OpenClaw MemMachine Plugin (Local Dev)

Source: https://docs.memmachine.ai/install_guide/integrate/openclaw

Install the MemMachine plugin for local development or testing by pointing to the local project path. Ensure you are in the project root.

```bash
openclaw plugins install ./MemMachine/integrations/openclaw
```

--------------------------------

### Search Memory Example

Source: https://docs.memmachine.ai/install_guide/integrate/claude_code_mcp

This is an example of a user query that prompts Claude Code to use the `search_memory` tool to recall stored information.

```text
What programming language do I prefer?
```

--------------------------------

### Tools List Response

Source: https://docs.memmachine.ai/examples/mcp

Example response containing the list of available tools and their schemas.

```json
event: message
data:
{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "tools": [
      {
        "name": "add_memory",
        "description": "Store important new information about the user or conversation into memory. Use this automatically whenever the user shares new facts, preferences, plans, emotions, or other details that could be useful for future context. Include the **full conversation context** in the `content` field — not just a snippet. This tool writes to both short-term (episodic) and long-term (profile) memory, so that future interactions can recall relevant background knowledge even across different sessions.",
        "inputSchema": {
          "$defs": {
            "AddMemoryParam": {
```

--------------------------------

### MemMachineClient Hello World Example

Source: https://docs.memmachine.ai/api_reference/python/client

This Python script demonstrates the fundamental MemMachine client workflow. It initializes the client, creates or retrieves a project, sets up a context-aware memory interface for a specific user and agent, adds user and assistant messages as memories, and then searches for relevant context based on a query. Ensure your MemMachine server is running at the specified base URL.

```python
import time
from memmachine_client import MemMachineClient

def main():
    # 1. Initialize the Client
    # Ensure your MemMachine server is running at this URL
    client = MemMachineClient(base_url="http://localhost:8080")

    # 2. Define a Project Workspace
    # Projects segregate data within an organization.
    # 'get_or_create_project' is idempotent; it returns the existing project if it exists.
    print("Initializing Project...")
    project = client.get_or_create_project(
        org_id="acme-corp",
        project_id="support-bot-v1",
        description="Memory store for customer support agent"
    )
    print(f"Connected to Project: {project.org_id}/{project.project_id}")

    # 3. Create a Context-Aware Memory Interface
    # This interface scopes all operations to a specific user and agent interaction.
    # - user_id: The end-user (human)
    # - agent_id: Your AI agent
    # - session_id: (Optional) A specific conversation thread
    memory = project.memory(
        user_id="alice_123",
        agent_id="support_bot_01",
        session_id="session_555"
    )

    # 4. Add Memories (Simulating a conversation)
    print("Adding memories...")

    # User states a preference
    memory.add(
        content="I am strictly vegetarian and I love spicy food.",
        role="user",
        metadata={"topic": "food_preference"}
    )

    # Agent acknowledges
    memory.add(
        content="Noted, I will recommend vegetarian spicy options.",
        role="assistant"
    )

    # 5. Search Memories
    # Retrieve relevant context for a new query
    print("\nSearching for context...")
    query = "What should I suggest for dinner?"
    results = memory.search(query)

    print(f"Query: {query}")
    print("Results found:")
    for idx, item in enumerate(results.get('episodic_memory', [])):
        print(f"[{idx+1}] {item['content']} (Role: {item['producer_role']})")

if __name__ == "__main__":
    main()

```

--------------------------------

### Start Ollama Service

Source: https://docs.memmachine.ai/install_guide/config/ollama

Run this command in your terminal to start the Ollama local API service. Ensure Ollama is installed first.

```bash
ollama serve
```

--------------------------------

### MemMachine Python SDK Hello World Example

Source: https://docs.memmachine.ai/examples/python

Demonstrates initializing the MemMachine client, creating a project, adding user and assistant memories, and searching for memories. Ensure your MemMachine server is running before execution.

```python
from memmachine_client import MemMachineClient

# 1. Initialize the client
# Replace 'http://localhost:8080' with your server's URL if different.
client = MemMachineClient(base_url="http://localhost:8080")

# 2. Create a Project
# Projects organize memories under an Organization.
# If the project already exists, this will return the existing one.
project = client.create_project(
    org_id="my-org",
    project_id="hello-world-project",
    description="My first MemMachine project"
)

print(f"Working with project: {project.org_id}/{project.project_id}")

# 3. Create a Memory Interface
# A Memory interface is scoped to a specific user/agent/session context.
memory = project.memory(
    user_id="user-alice",
    agent_id="agent-bob",
    session_id="session-1"
)

# 4. Add Memories
# Add a user message
memory.add(
    content="My favorite color is blue.",
    role="user"
)

# Add an agent response
memory.add(
    content="I'll remember that your favorite color is blue.",
    role="assistant"
)

print("Memories added.")

# 5. Search Memories
# Search for the information we just added.
results = memory.search("What is my favorite color?")

print("\nSearch Results:")
print(results)
```

--------------------------------

### Configure Proxy on Windows (PowerShell)

Source: https://docs.memmachine.ai/open_source/configuration

Set the standard proxy environment variables using PowerShell before starting the `memmachine-server` on Windows. This is for direct host machine installations.

```powershell
$env:HTTP_PROXY = "http://proxy.example.com:8080"
$env:HTTPS_PROXY = "http://proxy.example.com:8080"
$env:SSL_CERT_FILE = "C:\path\to\custom-ca-cert.pem"

memmachine-server
```

--------------------------------

### Clone and Install from Source

Source: https://docs.memmachine.ai/install_guide/install_guide

Use this method to run from the latest repository code or contribute to the project.

```sh
git clone https://github.com/MemMachine/MemMachine.git
cd MemMachine
```

```sh
# If you don't have uv installed, run this command:
curl -LsSf https://astral.sh/uv/install.sh | sh

# Now, install the project dependencies:
uv pip install .
```

--------------------------------

### Configure Proxy on Linux/MacOS

Source: https://docs.memmachine.ai/open_source/configuration

Export the standard proxy environment variables before starting the `memmachine-server` on Linux or MacOS. This is for direct host machine installations using pip or from source.

```bash
export HTTP_PROXY="http://proxy.example.com:8080"
export HTTPS_PROXY="http://proxy.example.com:8080"
export SSL_CERT_FILE="/path/to/custom-ca-cert.pem"

memmachine-server
```

--------------------------------

### SemanticMemory Usage Example

Source: https://docs.memmachine.ai/api_reference/ts-rest/interfaces/SemanticMemory

Example of how to access and log SemanticMemory data from a search response.

```APIDOC
## Usage Example

### Description
This example demonstrates how to access and log semantic memory data retrieved from a search response.

### Request Example
```typescript
const knowledge = searchResponse.content.semantic_memory;

console.log('Knowledge points:');
console.dir(knowledge , { depth: null });
```
```

--------------------------------

### Start MemMachine MCP Server

Source: https://docs.memmachine.ai/examples/mcp

Command to launch the MCP server using uv, requiring a configuration file.

```bash
MEMORY_CONFIG=config.yml uv run memmachine-mcp-http --host localhost --port 8080
```

--------------------------------

### Create Project

Source: https://docs.memmachine.ai/api_reference/ts-rest/classes/MemMachineProject

Initializes the project on the server. Throws a MemMachineAPIError if the request fails.

```typescript
create(options?: CreateProjectOptions): Promise<Project>
```

--------------------------------

### AddMemoryResult Usage Example

Source: https://docs.memmachine.ai/api_reference/ts-rest/interfaces/AddMemoryResult

Example demonstrating how to use the AddMemoryResult to access the UID of a saved memory.

```APIDOC
## Usage Example

```typescript
const result = await client.addEpisodicMemory(memoryData);

// Log the ID of the first added memory
if (result.results.length > 0) {
  console.log(`Memory saved with ID: ${result.results[0].uid}`);
}
```
```

--------------------------------

### Run configuration wizard

Source: https://docs.memmachine.ai/install_guide/configure_wizard

Execute the interactive wizard to generate the configuration file.

```bash
memmachine-configure
```

--------------------------------

### Initialize MemMachineClient with Options

Source: https://docs.memmachine.ai/api_reference/ts-rest/classes/MemMachineClient

Demonstrates initializing the MemMachineClient with an API key and accessing a specific project and memory instance. It's recommended to reuse a single client instance for performance.

```typescript
import MemMachineClient from '@memmachine/client';

async function main() {
  // 1. Initialize the client
  const client = new MemMachineClient({
    api_key: 'your_api_key'
  });

  // 2. Access a specific project
  const project = client.project({
    org_id: 'your_org_id',
    project_id: 'your_project_id'
  });

  // 3. Initialize memory for that project
  const memory = project.memory();

  // 4. Perform high-level health checks
  const status = await client.healthCheck();
  console.log(`Server Status: ${status.status}`);
}

main();
```

--------------------------------

### Start MemMachine Docker Container

Source: https://docs.memmachine.ai/install_guide/integrate/claude_code_mcp

Use this command to start the MemMachine Docker container in detached mode.

```bash
docker compose up -d
```

--------------------------------

### Client Initialization

Source: https://docs.memmachine.ai/api_reference/python/client_api

Initialize the MemMachineClient with base URL, API key, and timeout settings.

```APIDOC
## Client Initialization

### Description
Initialize the MemMachineClient with optional base URL, API key, and timeout.

### Parameters
#### Request Body
- **base_url** (str) - Required - The root URL of your MemMachine server.
- **api_key** (str) - Optional - Optional bearer token for authenticated environments.
- **timeout** (float) - Optional - Global request timeout in seconds. Defaults to 30.0.

### Request Example
```python
from memmachine_client import MemMachineClient

client = MemMachineClient(
    base_url="http://localhost:8080",
    api_key="your-api-key-here",
    timeout=30.0
)
```
```

--------------------------------

### Install NebulaGraph Python Client

Source: https://docs.memmachine.ai/install_guide/integrate/nebula_graph_integration_guide

Install the required Python client library for NebulaGraph version 5.2.1 or later.

```bash
pip install nebula5-python>=5.2.1
```

--------------------------------

### Run LangGraph Demo

Source: https://docs.memmachine.ai/install_guide/integrate/LangGraph

Navigate to the LangGraph example directory and execute the demo script to run the integrated workflow.

```bash
cd examples/langgraph
python demo.py
```

--------------------------------

### Create .env file with actual values

Source: https://docs.memmachine.ai/install_guide/cloud_deploy/aws_cloudformation

Creates a '.env' file and populates it with placeholder values for PostgreSQL, Neo4j, and OpenAI API keys, which are then replaced with actual environment variables using 'sed'.

```bash
# Create .env file with actual values
cat > .env << 'ENVEOF'
POSTGRES_PASSWORD=PLACEHOLDER_POSTGRES
NEO4J_PASSWORD=PLACEHOLDER_NEO4J
OPENAI_API_KEY=PLACEHOLDER_OPENAI
ENVEOF

# Replace placeholders with actual values
sed -i "s|PLACEHOLDER_POSTGRES|${PostgresPassword}|g" .env
sed -i "s|PLACEHOLDER_NEO4J|${Neo4jPassword}|g" .env
sed -i "s|PLACEHOLDER_OPENAI|${OpenAIApiKey}|g" .env
```

--------------------------------

### Create a Project via REST API

Source: https://docs.memmachine.ai/examples/rest

Initialize a new project with specific embedder and reranker configurations.

```bash
curl -X POST "http://127.0.0.1:8080/api/v2/projects" \
-H "Content-Type: application/json" \
-d '{
  "org_id": "my-org",
  "project_id": "my-first-project",
  "description": "A test project for REST API",
  "config": {
    "embedder": "my-openai-embedder",
    "reranker": "my-rrf-reranker"
  }
}'
```

--------------------------------

### Add Memory Example

Source: https://docs.memmachine.ai/install_guide/integrate/claude_code_mcp

This is an example of a user input that triggers Claude Code to use the `add_memory` tool to store a preference.

```text
Remember that I prefer using TypeScript for new projects
```

--------------------------------

### Project Usage Example

Source: https://docs.memmachine.ai/api_reference/ts-rest/classes/MemMachineProject

Demonstrates creating a project, checking memory count, and accessing memory operations.

```typescript
const project = client.project({ org_id: 'org_123', project_id: 'proj_456' });

// 1. Create the project if it doesn't exist
await project.create({ description: 'AI Assistant Context' });

// 2. Check the memory footprint
const count = await project.getEpisodicCount();
console.log(`Current memory count: ${count}`);

// 3. Access memory operations
const memory = project.memory();
```

--------------------------------

### Create a New Project

Source: https://docs.memmachine.ai/api_reference/python/project_api

Initializes a new project within an organization. If the project already exists, it returns the existing project details. Use this to set up a distinct memory space.

```python
project = client.projects.create(
    org_id="my_org",
    project_id="my_project",
    description="Main memory store for our customer support agent",
    metadata={"environment": "production"}
)
```

--------------------------------

### Start Claude Code

Source: https://docs.memmachine.ai/install_guide/integrate/claude_code_mcp

Run this command in your project directory to start Claude Code. Ensure MemMachine is configured to manage your project context.

```bash
claude
```

--------------------------------

### Initialize MemMachineClient with ClientOptions

Source: https://docs.memmachine.ai/api_reference/ts-rest/interfaces/ClientOptions

Configure the client by defining an options object with authentication and network parameters before instantiation.

```typescript
import { MemMachineClient, ClientOptions } from '@memmachine/client';

const config: ClientOptions = {
  api_key: 'mm_live_...',
  base_url: '[https://api.memmachine.ai](https://api.memmachine.ai)',
  timeout: 5000
};

const client = new MemMachineClient(config);
```

--------------------------------

### Initialize MemMachine Tools for CrewAI

Source: https://docs.memmachine.ai/install_guide/integrate/crewai

Use the `create_memmachine_tools` helper to initialize a list of tools for agents to interact with MemMachine. This simplifies setup by abstracting the underlying client. Provide your MemMachine backend URL and organization/project identifiers.

```python
from integrations.crewai.tool import create_memmachine_tools

# Initialize tools with your project configuration
memmachine_tools = create_memmachine_tools(
    base_url="http://localhost:8080",
    org_id="my_org",
    project_id="my_project",
    user_id="user123",
)
```

--------------------------------

### Configure MemMachine MCP for Local Install

Source: https://docs.memmachine.ai/install_guide/integrate/claude_code_mcp

This JSON configuration is for the `.mcp.json` file when MemMachine is installed locally. It specifies the direct command to run the MCP stdio interface.

```json
{
  "mcpServers": {
    "memmachine": {
      "command": "memmachine-mcp-stdio",
      "env": {
        "MEMORY_CONFIG": "/absolute/path/to/config.yml",
        "MM_USER_ID": "your-username",
        "PYTHONUNBUFFERED": "1"
      }
    }
  }
}
```

--------------------------------

### Run the Migration

Source: https://docs.memmachine.ai/tools/ChatGPT2MemMachine

Execute the migration script by specifying the input file, organization ID, project ID, and source format.

```bash
python migration.py -i conversations.json --org-id my-org --project-id my-project --source openai
```

--------------------------------

### GET /api/v2/config - Get System Configuration

Source: https://docs.memmachine.ai/api-reference/configuration/get-config

Retrieves the current configuration and resource status of the MemMachine system. This includes details about embedders, language models, rerankers, and databases, along with their initialization states.

```APIDOC
## GET /api/v2/config

### Description
Get current configuration and resource status. Returns a comprehensive view of all configured resources in the system, including embedders, language models, rerankers, and databases. Each resource includes its current status (ready, failed, or pending) and any error messages if initialization failed.

This endpoint is useful for:
- Monitoring the health of configured resources
- Diagnosing startup failures when resources are unavailable
- Verifying that runtime configuration changes have been applied

Resources may be in one of three states:
- `ready`: The resource is initialized and available for use
- `failed`: The resource failed to initialize (error details included)
- `pending`: The resource is configured but not yet initialized

### Method
GET

### Endpoint
/api/v2/config

### Parameters

### Request Body

### Request Example

### Response
#### Success Response (200)
- **resources** (object) - The status of all configured resources.
- **episodic_memory** (object) - Current episodic memory configuration including both long-term and short-term memory.
- **semantic_memory** (object) - Current semantic memory configuration.

#### Response Example
{
  "resources": {
    "embedders": [
      {
        "name": "string",
        "status": "ready | failed | pending",
        "error": "string"
      }
    ],
    "language_models": [
      {
        "name": "string",
        "status": "ready | failed | pending",
        "error": "string"
      }
    ],
    "rerankers": [
      {
        "name": "string",
        "status": "ready | failed | pending",
        "error": "string"
      }
    ],
    "databases": [
      {
        "name": "string",
        "status": "ready | failed | pending",
        "error": "string"
      }
    ]
  },
  "episodic_memory": {
    "long_term_memory": {
      "enabled": true
    },
    "short_term_memory": {
      "enabled": true
    },
    "enabled": true
  },
  "semantic_memory": {
    "enabled": true
  }
}
```

--------------------------------

### GET /semantic-set-id

Source: https://docs.memmachine.ai/api-reference/semantic-memory%3A-sets/get-semantic-set-id

Retrieves the identifier for a semantic set.

```APIDOC
## GET /semantic-set-id

### Description
Retrieves the unique identifier for a semantic set.

### Method
GET

### Endpoint
/semantic-set-id

### Response
#### Success Response (200)
- **set_id** (string) - Identifier of the semantic set.

#### Response Example
{
  "set_id": "string"
}
```

--------------------------------

### Initialize MemmachineMemoryService

Source: https://docs.memmachine.ai/install_guide/integrate/Google_ADK

Create the memory service instance using your API credentials and endpoint configuration.

```python
from memmachine_server.integrations.google_adk.memmachine_memory_service import MemmachineMemoryService

memory_service = MemmachineMemoryService(
    api_key="YOUR_API_KEY",
    endpoint="http://localhost:8080/api/v2", # Use for self-hosted
    org_id="my-org",
    project_id="my-project"
)
```
Tokens:
Raw