### Install Nova Memory MCP Server

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Install the MCP server globally using npm. Verify the installation by checking the version.

```bash
# Install globally
npm install -g @nova-mcp/mcp-nova

# Verify installation
mcp-nova --version
```

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

### Install Nova Memory CLI

Source: https://github.com/jagdeepsinghdev/nova-memory/blob/main/README.md

Install the Nova Memory command-line interface globally using npm.

```bash
npm install -g @nova-mcp/mcp-nova
```

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

### Get Task Board Overview

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Use the `task_board` tool to retrieve a structured overview of tasks grouped by status. Supports filtering by project and phase.

```jsonc
{
  "tool": "task_board",
  "arguments": {
    "project": "my-project",
    "phase": "backend"
  }
}
```

```jsonc
// Expected response
{
  "board": {
    "pending": [
      { "id": "task_01HZ9A3B4C5D6E7F8G9H0I1J", "title": "Migrate auth service to PostgreSQL", "priority": "high" }
    ],
    "active": [],
    "completed": [
      { "id": "task_00HZ1X2Y3Z4A5B6C7D8E9F0G", "title": "Set up CI pipeline", "priority": "medium" }
    ]
  },
  "summary": { "pending": 1, "active": 0, "completed": 1 }
}
```

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

### Manage Project Architecture Profile

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

The `project_profile` tool allows you to store or retrieve a structured profile of your project, including its tech stack, architecture, and conventions. Use `action: "set"` to store and `action: "get"` to retrieve.

```jsonc
// Store a profile
{
  "tool": "project_profile",
  "arguments": {
    "action": "set",
    "profile": {
      "name": "my-project",
      "stack": ["Node.js", "TypeScript", "PostgreSQL", "React 18", "Vite"],
      "architecture": "Monorepo with services/auth, services/gateway, apps/web",
      "conventions": {
        "branch_naming": "feat/<ticket>-<short-description>",
        "commit_style": "Conventional Commits"
      },
      "entry_points": {
        "api": "services/gateway/src/index.ts",
        "web": "apps/web/src/main.tsx"
      }
    }
  }
}
```

```jsonc
// Retrieve the profile
{
  "tool": "project_profile",
  "arguments": { "action": "get", "project": "my-project" }
}
```

```jsonc
// Expected get response
{
  "name": "my-project",
  "stack": ["Node.js", "TypeScript", "PostgreSQL", "React 18", "Vite"],
  "architecture": "Monorepo with services/auth, services/gateway, apps/web",
  "conventions": { "branch_naming": "feat/<ticket>-<short-description>" },
  "updated_at": "2024-11-12T10:30:00Z"
}
```

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

### Get Memory Storage Statistics

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Retrieve statistics about memory storage, including total counts, counts by type, total tags, and storage size. You can filter by project.

```json
{
  "tool": "memory_stats",
  "arguments": {
    "project": "my-project"
  }
}
```

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

### Get AI-Powered Task Analytics

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Utilize the `task_insights` tool for AI-driven analysis of task history. It identifies bottlenecks, trends, and completion rates over a specified period.

```jsonc
{
  "tool": "task_insights",
  "arguments": {
    "project": "my-project",
    "period_days": 30
  }
}
```

```jsonc
// Expected response
{
  "velocity": { "completed_last_30d": 12, "avg_days_to_complete": 3.4 },
  "bottlenecks": ["backend phase has 4 overdue tasks"],
  "phase_completion": {
    "backend": "60%",
    "frontend": "80%",
    "devops": "100%"
  },
  "recommendations": [
    "3 high-priority tasks in 'backend' phase have been pending for over 7 days."
  ]
}
```

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

### Configure Nova Memory Project Settings

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Create a `.nova/config.json` file in your project root to control storage mode, enabled features, and available tools. Omitting a key uses the default settings.

```json
// .nova/config.json
{
  "storage": {
    "mode": "project"
  },
  "features": {
    "taskManagement": true,
    "knowledgeGraph": true
  },
  "tools": {
    "search_patterns": true,
    "analysis_conflicts": true,
    "project_profile": true,
    "search_semantic": true,
    "analysis_anomalies": false,
    "analysis_forecast": false
  }
}
```

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

### Create and Manage Tasks

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Create tasks with details like title, description, phase, priority, tags, and subtasks. Supports progress tracking and returns the created task details.

```json
{
  "tool": "task_management",
  "arguments": {
    "action": "create",
    "title": "Migrate auth service to PostgreSQL",
    "description": "Switch the auth database from MySQL to PostgreSQL following the architecture decision.",
    "phase": "backend",
    "priority": "high",
    "tags": ["database", "auth-service"],
    "subtasks": [
      "Write migration scripts",
      "Update connection strings in config",
      "Run integration tests"
    ]
  }
}
```

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

### Configure Nova Memory for Multi-Project Storage

Source: https://github.com/jagdeepsinghdev/nova-memory/blob/main/README.md

Enable and configure multi-project storage mode, specifying paths to include for cross-project queries.

```json
{
  "storage": {
    "mode": "multi",
    "multiProject": {
      "enabled": true,
      "includePaths": ["~/projects/api", "~/projects/web"]
    }
  }
}
```

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

### Configure Nova Memory for Claude Desktop

Source: https://github.com/jagdeepsinghdev/nova-memory/blob/main/README.md

Add Nova Memory as an MCP server in the Claude Desktop configuration file.

```json
{
  "mcpServers": {
    "nova-memory": {
      "command": "npx",
      "args": ["@nova-mcp/mcp-nova"]
    }
  }
}
```

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

### Configure Nova Memory Project Settings

Source: https://github.com/jagdeepsinghdev/nova-memory/blob/main/README.md

Customize Nova Memory's storage mode, enabled features, and specific tools via a configuration file.

```json
{
  "storage": {
    "mode": "project"
  },
  "features": {
    "taskManagement": true,
    "knowledgeGraph": true
  },
  "tools": {
    "search_patterns": true,
    "analysis_conflicts": true,
    "project_profile": true
  }
}
```

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

### Multi-Project Storage Configuration

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Configure Nova Memory to query across multiple project databases simultaneously by setting `storage.mode` to `"multi"` and `storage.multiProject.enabled` to `true` in `.nova/config.json`. Specify the paths to include in `includePaths`.

```json
// .nova/config.json
{
  "storage": {
    "mode": "multi",
    "multiProject": {
      "enabled": true,
      "includePaths": [
        "~/projects/api",
        "~/projects/web",
        "~/projects/infra"
      ]
    }
  }
}
```

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

### Configure Nova Memory in Claude Desktop

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Register Nova Memory as an MCP server in the Claude Desktop configuration file to make it available in all conversations. The configuration specifies the command and arguments to run the server.

```json
// macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
// Windows: %APPDATA%\Claude\claude_desktop_config.json
{
  "mcpServers": {
    "nova-memory": {
      "command": "npx",
      "args": ["@nova-mcp/mcp-nova"]
    }
  }
}
```

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

### Store Memory with `store_memory` Tool

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Use the `store_memory` tool to save content with optional type, tags, and file path. The server auto-tags and indexes the content. Returns the ID of the created memory entry.

```jsonc
// MCP tool call (as sent by the AI client)
{
  "tool": "store_memory",
  "arguments": {
    "content": "Decided to use PostgreSQL instead of MySQL for the auth service due to better JSON support and row-level security features.",
    "type": "decision",
    "tags": ["database", "auth-service", "architecture"],
    "path": "services/auth"
  }
}

// Expected response
{
  "id": "mem_01HZ8K2N3P4Q5R6S7T8U9V0W",
  "status": "stored",
  "tags": ["database", "auth-service", "architecture", "postgresql"],
  "project": "my-project"
}
```

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

### Full-Text Search with `memory_search` Tool

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Perform a full-text search using BM25 ranking on stored memories. Accepts a query and optional filters for type or project. Returns ranked results with relevance scores.

```jsonc
{
  "tool": "memory_search",
  "arguments": {
    "query": "database decision auth service",
    "limit": 5,
    "type": "decision"
  }
}

// Expected response
{
  "results": [
    {
      "id": "mem_01HZ8K2N3P4R6S7T8U9V0W",
      "content": "Decided to use PostgreSQL instead of MySQL for the auth service...",
      "score": 0.94,
      "tags": ["database", "auth-service", "architecture"],
      "created_at": "2024-11-12T10:22:00Z"
    }
  ],
  "total": 1
}
```

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

### List All Tags with Usage Counts

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Obtain a list of all tags present in the memory store, sorted by their frequency. Useful for understanding knowledge categorization. A limit can be applied.

```json
{
  "tool": "memory_tags",
  "arguments": {
    "project": "my-project",
    "limit": 10
  }
}
```

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

### Add Nova Memory Server via Claude Code CLI

Source: https://github.com/jagdeepsinghdev/nova-memory/blob/main/README.md

Use the Claude Code CLI to add Nova Memory as an MCP server.

```bash
claude mcp add nova-memory -- npx @nova-mcp/mcp-nova
```

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

### task_management

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Creates tasks with optional phases, priority levels, and assignees. Supports sub-tasks and progress tracking. Returns the created task with a unique ID.

```APIDOC
## task_management — Create and Manage Tasks

### Description
Creates tasks with optional phases, priority levels, and assignees. Supports sub-tasks and progress tracking. Returns the created task with a unique ID.

### Arguments
- **action** (string) - Required - The action to perform (e.g., `create`).
- **title** (string) - Required - The title of the task.
- **description** (string) - Optional - A detailed description of the task.
- **phase** (string) - Optional - The phase the task belongs to (e.g., `backend`, `frontend`).
- **priority** (string) - Optional - The priority level of the task (e.g., `high`, `medium`, `low`).
- **tags** (array) - Optional - An array of tags associated with the task.
- **subtasks** (array) - Optional - An array of sub-task titles.

### Request Example
```json
{
  "tool": "task_management",
  "arguments": {
    "action": "create",
    "title": "Migrate auth service to PostgreSQL",
    "description": "Switch the auth database from MySQL to PostgreSQL following the architecture decision.",
    "phase": "backend",
    "priority": "high",
    "tags": ["database", "auth-service"],
    "subtasks": [
      "Write migration scripts",
      "Update connection strings in config",
      "Run integration tests"
    ]
  }
}
```

### Response Example
```json
{
  "id": "task_01HZ9A3B4C5D6E7F8G9H0I1J",
  "title": "Migrate auth service to PostgreSQL",
  "status": "pending",
  "phase": "backend",
  "priority": "high",
  "subtasks": [
    { "id": "sub_1", "title": "Write migration scripts", "status": "pending" },
    { "id": "sub_2", "title": "Update connection strings in config", "status": "pending" },
    { "id": "sub_3", "title": "Run integration tests", "status": "pending" }
  ],
  "created_at": "2024-11-12T11:00:00Z"
}
```
```

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

### Optimize and Compact Storage

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Run `memory_compact` periodically to maintain the SQLite database. This tool removes orphaned records, rebuilds the FTS index, and reclaims disk space. Set `rebuild_index` to `true` to rebuild the index.

```jsonc
{
  "tool": "memory_compact",
  "arguments": {
    "project": "my-project",
    "rebuild_index": true
  }
}
```

```jsonc
// Expected response
{
  "status": "completed",
  "removed_orphans": 3,
  "index_rebuilt": true,
  "size_before_bytes": 204800,
  "size_after_bytes": 180224,
  "saved_bytes": 24576
}
```

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

### Explore Memory Connections

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Use `search_relationships` to traverse links between memories and knowledge graph nodes. Specify a memory ID, depth, and relationship types to find related content.

```jsonc
{
  "tool": "search_relationships",
  "arguments": {
    "memory_id": "mem_01HZ8K2N3P4Q5R6S7T8U9V0W",
    "depth": 2,
    "relationship_types": ["depends_on", "related_to"]
  }
}
```

```jsonc
// Expected response
{
  "origin": "mem_01HZ8K2N3P4Q5R6S7T8U9V0W",
  "related": [
    { "id": "mem_047", "content": "PostgreSQL connection pool config set to 20.", "distance": 1 },
    { "id": "mem_089", "content": "pgBouncer configured for transaction pooling.", "distance": 2 }
  ]
}
```

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

### Bulk Import Memories from JSON

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Import multiple memory objects from a JSON array. Supports handling conflicts by skipping duplicates. Specify the project and conflict resolution strategy.

```json
{
  "tool": "memory_import",
  "arguments": {
    "memories": [
      {
        "content": "API rate limits set to 1000 req/min per tenant.",
        "type": "decision",
        "tags": ["api", "rate-limiting"],
        "path": "services/gateway"
      },
      {
        "content": "Frontend uses React 18 with Vite for bundling.",
        "type": "note",
        "tags": ["frontend", "tooling"],
        "path": "apps/web"
      }
    ],
    "project": "my-project",
    "on_conflict": "skip"
  }
}
```

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

### Time-Based Memory Analysis

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Utilize `search_temporal` to retrieve memories within a specified date range, optionally grouped by week. This is useful for reviewing activities during specific periods.

```jsonc
{
  "tool": "search_temporal",
  "arguments": {
    "from": "2024-11-01",
    "to": "2024-11-12",
    "group_by": "week",
    "project": "my-project"
  }
}
```

```jsonc
// Expected response
{
  "groups": [
    {
      "period": "2024-W44",
      "count": 18,
      "memories": [
        { "id": "mem_001", "content": "Kicked off auth service redesign.", "created_at": "2024-11-04" }
      ]
    },
    {
      "period": "2024-W45",
      "count": 24,
      "memories": [
        { "id": "mem_019", "content": "Decided on PostgreSQL for auth.", "created_at": "2024-11-12" }
      ]
    }
  ]
}
```

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

### memory_stats

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Returns counts and storage metrics for all memories in the current project or globally.

```APIDOC
## memory_stats — Storage Statistics

### Description
Returns counts and storage metrics for all memories in the current project or globally.

### Arguments
- **project** (string) - Optional - The project to retrieve statistics for. If not provided, global statistics are returned.

### Request Example
```json
{
  "tool": "memory_stats",
  "arguments": {
    "project": "my-project"
  }
}
```

### Response Example
```json
{
  "total_memories": 142,
  "by_type": {
    "decision": 34,
    "note": 61,
    "code": 28,
    "task": 19
  },
  "total_tags": 87,
  "storage_bytes": 204800,
  "project": "my-project"
}
```
```

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

### Export Memories as Markdown or JSON

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Export memories in either Markdown or JSON format. You can filter by type and project. This is useful for backups or sharing.

```json
{
  "tool": "memory_export",
  "arguments": {
    "format": "markdown",
    "type": "decision",
    "project": "my-project"
  }
}
```

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

### memory_tags

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Returns all tags that exist in the current project's memory store, sorted by frequency. Useful for discovering what categories of knowledge have been stored.

```APIDOC
## memory_tags — List All Tags with Usage Counts

### Description
Returns all tags that exist in the current project's memory store, sorted by frequency. Useful for discovering what categories of knowledge have been stored.

### Arguments
- **project** (string) - Optional - The project to list tags from. If not provided, tags from all projects are returned.
- **limit** (integer) - Optional - The maximum number of tags to return.

### Request Example
```json
{
  "tool": "memory_tags",
  "arguments": {
    "project": "my-project",
    "limit": 10
  }
}
```

### Response Example
```json
{
  "tags": [
    { "name": "architecture", "count": 23 },
    { "name": "database", "count": 17 },
    { "name": "auth-service", "count": 12 },
    { "name": "api", "count": 9 }
  ],
  "total_unique_tags": 87
}
```
```

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

### Generate Memory Map Visualization

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

The `analysis_memory_map` tool generates a visualization of memories grouped by type, tags, or path relationships. Specify the project and grouping criteria.

```jsonc
{
  "tool": "analysis_memory_map",
  "arguments": {
    "project": "my-project",
    "group_by": "type"
  }
}
```

```jsonc
// Expected response
{
  "map": {
    "decision": { "count": 34, "top_tags": ["architecture", "database", "api"] },
    "note": { "count": 61, "top_tags": ["frontend", "tooling", "meetings"] },
    "code": { "count": 28, "top_tags": ["auth-service", "gateway", "utils"] }
  },
  "paths": ["services/auth", "services/gateway", "apps/web"],
  "generated_at": "2024-11-12T12:00:00Z"
}
```

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

### Filter Memories by Metadata with `memory_query` Tool

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Retrieve memories filtered by metadata such as type, tags, project, or file path without full-text ranking. Useful for browsing memories by category. Supports pagination.

```jsonc
{
  "tool": "memory_query",
  "arguments": {
    "type": "decision",
    "tags": ["architecture"],
    "project": "my-project",
    "limit": 20,
    "offset": 0
  }
}

// Expected response
{
  "memories": [
    {
      "id": "mem_01HZ8K2N3P4Q5R6S7T8U9V0W",
      "content": "Decided to use PostgreSQL...",
      "type": "decision",
      "tags": ["database", "auth-service", "architecture"],
      "path": "services/auth",
      "created_at": "2024-11-12T10:22:00Z"
    }
  ],
  "total": 1,
  "page": 1
}
```

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

### memory_import

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Imports a JSON array of memory objects into the store. Supports deduplication and merge strategies for existing records.

```APIDOC
## memory_import — Bulk Import Memories from JSON

### Description
Imports a JSON array of memory objects into the store. Supports deduplication and merge strategies for existing records.

### Arguments
- **memories** (array) - Required - An array of memory objects to import.
  - **content** (string) - Required - The content of the memory.
  - **type** (string) - Optional - The type of the memory (e.g., `decision`, `note`).
  - **tags** (array) - Optional - An array of tags associated with the memory.
  - **path** (string) - Optional - A path associated with the memory.
- **project** (string) - Optional - The project to import memories into.
- **on_conflict** (string) - Optional - Strategy for handling conflicts (`skip`, `update`, `error`). Defaults to `skip`.

### Request Example
```json
{
  "tool": "memory_import",
  "arguments": {
    "memories": [
      {
        "content": "API rate limits set to 1000 req/min per tenant.",
        "type": "decision",
        "tags": ["api", "rate-limiting"],
        "path": "services/gateway"
      },
      {
        "content": "Frontend uses React 18 with Vite for bundling.",
        "type": "note",
        "tags": ["frontend", "tooling"],
        "path": "apps/web"
      }
    ],
    "project": "my-project",
    "on_conflict": "skip"
  }
}
```

### Response Example
```json
{
  "imported": 2,
  "skipped": 0,
  "errors": [],
  "project": "my-project"
}
```
```

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

### Manage Knowledge Graph Relationships

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

The `knowledge_graph` tool allows adding edges (relationships) between nodes and querying existing relationships. Specify action, nodes, relationship type, and optional metadata.

```jsonc
// Add a relationship
{
  "tool": "knowledge_graph",
  "arguments": {
    "action": "add_edge",
    "from": "auth-service",
    "to": "postgresql",
    "relationship": "depends_on",
    "metadata": { "reason": "architecture decision 2024-11-12" }
  }
}
```

```jsonc
// Query relationships
{
  "tool": "knowledge_graph",
  "arguments": {
    "action": "query",
    "node": "auth-service",
    "depth": 2
  }
}
```

```jsonc
// Expected query response
{
  "node": "auth-service",
  "edges": [
    { "to": "postgresql", "relationship": "depends_on" },
    { "to": "jwt-library", "relationship": "uses" },
    { "to": "user-service", "relationship": "called_by" }
  ],
  "indirect": [
    { "path": ["auth-service", "postgresql", "pgbouncer"], "relationship_chain": ["depends_on", "routed_through"] }
  ]
}
```

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

### store_memory

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Stores any piece of content with an optional type, tags, and file path. The server auto-tags and indexes the content for later retrieval. Returns the ID of the created memory entry.

```APIDOC
## store_memory — Store a Memory

### Description
Stores any piece of content with an optional type, tags, and file path. The server auto-tags and indexes the content for later retrieval. Returns the ID of the created memory entry.

### Tool
store_memory

### Arguments
- **content** (string) - Required - The content to store.
- **type** (string) - Optional - The type of memory (e.g., 'decision', 'note').
- **tags** (array of strings) - Optional - Tags to associate with the memory.
- **path** (string) - Optional - The file path associated with the memory.

### Request Example
```jsonc
{
  "tool": "store_memory",
  "arguments": {
    "content": "Decided to use PostgreSQL instead of MySQL for the auth service due to better JSON support and row-level security features.",
    "type": "decision",
    "tags": ["database", "auth-service", "architecture"],
    "path": "services/auth"
  }
}
```

### Response Example
```json
{
  "id": "mem_01HZ8K2N3P4Q5R6S7T8U9V0W",
  "status": "stored",
  "tags": ["database", "auth-service", "architecture", "postgresql"],
  "project": "my-project"
}
```
```

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

### Perform Semantic Similarity Search

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Use this tool to find memories based on their conceptual meaning, not just keywords. Specify a query, a limit for results, and a similarity threshold.

```json
{
  "tool": "search_semantic",
  "arguments": {
    "query": "why did we choose our database technology",
    "limit": 3,
    "threshold": 0.7
  }
}
```

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

### memory_search

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Searches all stored memories using BM25 ranking. Accepts a natural-language query and optional filters for type or project. Returns ranked results with relevance scores.

```APIDOC
## memory_search — Full-Text Search with BM25

### Description
Searches all stored memories using BM25 ranking. Accepts a natural-language query and optional filters for type or project. Returns ranked results with relevance scores.

### Tool
memory_search

### Arguments
- **query** (string) - Required - The natural-language query.
- **limit** (integer) - Optional - The maximum number of results to return.
- **type** (string) - Optional - Filter results by memory type.

### Request Example
```jsonc
{
  "tool": "memory_search",
  "arguments": {
    "query": "database decision auth service",
    "limit": 5,
    "type": "decision"
  }
}
```

### Response Example
```json
{
  "results": [
    {
      "id": "mem_01HZ8K2N3P4Q5R6S7T8U9V0W",
      "content": "Decided to use PostgreSQL instead of MySQL for the auth service...",
      "score": 0.94,
      "tags": ["database", "auth-service", "architecture"],
      "created_at": "2024-11-12T10:22:00Z"
    }
  ],
  "total": 1
}
```
```

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

### Search for Recurring Patterns

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Use `search_patterns` to find frequently occurring themes or phrases across memories. Specify the project, minimum frequency, and a limit for the number of patterns to return.

```jsonc
{
  "tool": "search_patterns",
  "arguments": {
    "project": "my-project",
    "min_frequency": 3,
    "limit": 5
  }
}
```

```jsonc
// Expected response
{
  "patterns": [
    { "pattern": "rate limiting", "frequency": 7, "memory_ids": ["mem_011", "mem_034", "mem_067", "..."] },
    { "pattern": "authentication flow", "frequency": 5, "memory_ids": ["mem_002", "mem_019", "..."] }
  ]
}
```

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

### memory_query

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Retrieves memories filtered by type, tags, project, or file path without full-text ranking. Useful for browsing all memories of a specific category.

```APIDOC
## memory_query — Filter Memories by Metadata

### Description
Retrieves memories filtered by type, tags, project, or file path without full-text ranking. Useful for browsing all memories of a specific category.

### Tool
memory_query

### Arguments
- **type** (string) - Optional - Filter results by memory type.
- **tags** (array of strings) - Optional - Filter results by tags.
- **project** (string) - Optional - Filter results by project.
- **limit** (integer) - Optional - The maximum number of results to return.
- **offset** (integer) - Optional - The number of results to skip.

### Request Example
```jsonc
{
  "tool": "memory_query",
  "arguments": {
    "type": "decision",
    "tags": ["architecture"],
    "project": "my-project",
    "limit": 20,
    "offset": 0
  }
}
```

### Response Example
```json
{
  "memories": [
    {
      "id": "mem_01HZ8K2N3P4Q5R6S7T8U9V0W",
      "content": "Decided to use PostgreSQL...",
      "type": "decision",
      "tags": ["database", "auth-service", "architecture"],
      "path": "services/auth",
      "created_at": "2024-11-12T10:22:00Z"
    }
  ],
  "total": 1,
  "page": 1
}
```
```

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

### Detect Conflicts Between Memories

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Use `analysis_conflicts` to scan memories for contradictions. Specify the project and the type of memory to analyze (e.g., 'decision').

```jsonc
{
  "tool": "analysis_conflicts",
  "arguments": {
    "project": "my-project",
    "type": "decision"
  }
}
```

```jsonc
// Expected response
{
  "conflicts": [
    {
      "memory_a": { "id": "mem_001", "content": "Use Redis for session storage." },
      "memory_b": { "id": "mem_047", "content": "Sessions stored in PostgreSQL for consistency with other user data." },
      "conflict_type": "contradiction",
      "confidence": 0.91,
      "suggestion": "Clarify which storage backend is authoritative for session data."
    }
  ],
  "total_conflicts": 1
}
```

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

### memory_export

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Exports all memories (or a filtered subset) as a JSON array or formatted Markdown document. Useful for backups, reviews, or sharing context with other tools.

```APIDOC
## memory_export — Export Memories as JSON or Markdown

### Description
Exports all memories (or a filtered subset) as a JSON array or formatted Markdown document. Useful for backups, reviews, or sharing context with other tools.

### Arguments
- **format** (string) - Required - The desired output format (`json` or `markdown`).
- **type** (string) - Optional - Filter memories by type (e.g., `decision`, `note`).
- **project** (string) - Optional - Filter memories by project.

### Request Example
```json
{
  "tool": "memory_export",
  "arguments": {
    "format": "markdown",
    "type": "decision",
    "project": "my-project"
  }
}
```

### Response Example (markdown format)
```json
{
  "content": "# Exported Memories — my-project\n\n## decision\n\n### 2024-11-12\n**Tags:** database, auth-service, architecture\n\nDecided to use PostgreSQL instead of MySQL...\n\n---\n",
  "count": 34,
  "format": "markdown"
}
```
```

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

### Find Unusual Patterns in Memories

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Use `analysis_anomalies` to detect statistical outliers in memories, such as unusually old, rarely accessed, or untagged items. Requires project and a threshold for anomaly detection.

```jsonc
{
  "tool": "analysis_anomalies",
  "arguments": {
    "project": "my-project",
    "threshold": 0.8
  }
}
```

```jsonc
// Expected response
{
  "anomalies": [
    {
      "id": "mem_023",
      "reason": "No tags assigned and no graph relationships",
      "content_preview": "TODO: check if the legacy endpoint is still needed...",
      "anomaly_score": 0.93
    }
  ],
  "total": 1
}
```

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

### Delete a Memory by ID

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Permanently remove a memory entry using its unique identifier. This action is irreversible.

```json
{
  "tool": "memory_delete",
  "arguments": {
    "id": "mem_01HZ8K2N3P4Q5R6S7T8U9V0W"
  }
}
```

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

### search_semantic

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Finds memories by semantic meaning rather than keyword overlap. Useful when the exact wording of a memory is unknown but the concept is clear.

```APIDOC
## search_semantic — Semantic Similarity Search

### Description
Finds memories by semantic meaning rather than keyword overlap. Useful when the exact wording of a memory is unknown but the concept is clear.

### Arguments
- **query** (string) - Required - The semantic query to search for.
- **limit** (integer) - Optional - The maximum number of results to return.
- **threshold** (float) - Optional - The minimum similarity score for a result to be included.

### Request Example
```json
{
  "tool": "search_semantic",
  "arguments": {
    "query": "why did we choose our database technology",
    "limit": 3,
    "threshold": 0.7
  }
}
```

### Response Example
```json
{
  "results": [
    {
      "id": "mem_01HZ8K2N3P4Q5R6S7T8U9V0W",
      "content": "Decided to use PostgreSQL instead of MySQL...",
      "similarity": 0.87,
      "tags": ["database", "auth-service", "architecture"]
    }
  ]
}
```
```

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

### memory_delete

Source: https://context7.com/jagdeepsinghdev/nova-memory/llms.txt

Removes a single memory entry by its ID. The operation is permanent and cannot be undone.

```APIDOC
## memory_delete — Delete a Memory by ID

### Description
Removes a single memory entry by its ID. The operation is permanent and cannot be undone.

### Arguments
- **id** (string) - Required - The ID of the memory to delete.

### Request Example
```json
{
  "tool": "memory_delete",
  "arguments": {
    "id": "mem_01HZ8K2N3P4Q5R6S7T8U9V0W"
  }
}
```

### Response Example
```json
{
  "status": "deleted",
  "id": "mem_01HZ8K2N3P4Q5R6S7T8U9V0W"
}
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.