Skip to main content
Glama
jaenster

MindPort MCP Server

by jaenster
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Local

MindPort MCP Server

A high-performance Model Context Protocol (MCP) server built in TypeScript/Node.js that provides optimized storage and search capabilities for AI systems. Designed for seamless integration with Claude Desktop and other MCP clients.

Features

  • Advanced Search: Token-efficient fuzzy search, regex patterns, and grep-like functionality

  • SQLite Storage: Reliable, lightweight database with domain isolation

  • Smart Organization: Domain-based resource management with tag filtering

  • AI-Optimized: Designed specifically for Claude Desktop/Code integration

  • High Performance: Fast search and retrieval optimized for large datasets

  • Comprehensive Testing: 76+ tests covering all functionality

  • Prompt Templates: Store and render reusable prompt templates with variables

  • Modern Web Interface: Professional dashboard for browsing and managing resources

Related MCP server: MCP Server + Document Memory System

Installation

NPM Package

npm install -g mindport-mcp
mindport --help

From Source

git clone https://github.com/mindport-ai/mcp-mindport.git
cd mcp-mindport
npm install
npm run build

Production Deployment

# Install globally
npm install -g mindport-mcp

# Or run with npx
npx mindport-mcp

# Start web interface
npx mindport-mcp --web

The installation automatically:

  • Installs all dependencies

  • Sets up SQLite database

  • Configures default settings

  • Creates necessary directories

Quick Start

Development Mode

# Install dependencies
npm install

# Start MCP server (for Claude Desktop)
npm run dev

# Start web interface (in new terminal)
npm run web
# Visit http://localhost:3001

Production Mode

# Build for production
npm run build

# Start production server
npm start

# Start web interface
npm run web:start

Testing

# Run comprehensive test suite
npm test

# Run tests once
npm run test:run

# Run with coverage
npm run test:coverage

Production Deployment

Publishing to NPM

# Prepare for release
npm run build
npm run test:run

# Publish to NPM
npm publish

# Install globally from NPM
npm install -g mindport-mcp

Docker Deployment

# Build Docker image
docker build -t mindport-mcp .

# Run in container
docker run -d -p 3001:3001 \
  -v ~/.config/mindport:/root/.config/mindport \
  mindport-mcp

Production Server Setup

# Install globally
npm install -g mindport-mcp

# Create systemd service (Linux)
sudo tee /etc/systemd/system/mindport.service << EOF
[Unit]
Description=MindPort MCP Server
After=network.target

[Service]
Type=simple
User=mindport
WorkingDirectory=/opt/mindport
ExecStart=/usr/bin/node /usr/local/bin/mindport-mcp
Restart=always
Environment=NODE_ENV=production
Environment=MCP_MINDPORT_LOG=/var/log/mindport.log

[Install]
WantedBy=multi-user.target
EOF

# Enable and start service
sudo systemctl enable mindport
sudo systemctl start mindport

Configuration

The server automatically creates configuration at ~/.config/mindport/config.yaml:

server:
  host: "localhost"
  port: 8080

storage:
  path: "~/.config/mindport/data/storage.db"

search:
  index_path: "~/.config/mindport/data/search"

domain:
  default_domain: "default"

Environment Variables

# Disable logging (recommended for MCP)
export MCP_MINDPORT_LOG=discard

# Set custom domain
export MCP_MINDPORT_DOMAIN=my-project

# Custom storage path
export MCP_MINDPORT_STORE_PATH=/path/to/storage.db

Claude Desktop Integration

Add to your Claude Desktop configuration (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "mindport": {
      "command": "npx",
      "args": ["mindport-mcp"],
      "env": {
        "MCP_MINDPORT_LOG": "discard"
      }
    }
  }
}

Restart Claude Desktop to activate MindPort.

Available MCP Tools

Resource Management

store_resource

Store content with metadata and tags

{
  id: "api-docs-v1",
  name: "API Documentation", 
  description: "REST API endpoints and authentication",
  content: "GET /users - Retrieve users...",
  tags: ["api", "documentation", "rest"],
  mimeType: "text/markdown"
}

get_resource

Retrieve specific resource by ID

{ id: "api-docs-v1" }

list_resources

List resources in current domain

{ limit: 20, offset: 0 }

Search & Discovery

search_resources

Fast, token-efficient fuzzy search

{
  query: "API authentication methods",
  limit: 10
}

advanced_search

Complex queries with tag filtering

{
  query: "database design",
  tags: ["sql", "performance"],
  exactTags: true
}

grep

Regex pattern matching (like ripgrep)

{ pattern: "function\\s+\\w+\\(" }

find

Find resources by name patterns

{ pattern: "^API.*" }

Domain Management

list_domains

List all available domains

{}

create_domain

Create new domain context

{
  name: "frontend-project",
  description: "Frontend development resources"
}

switch_domain

Change current domain

{ domain: "frontend-project" }

domain_stats

Get domain statistics and top tags

{ domain: "frontend-project" }  // optional

Prompt Templates

store_prompt

Store reusable prompt templates

{
  id: "code-review",
  name: "Code Review Prompt",
  template: "Review this {{language}} code for {{focus}}:\n\n```{{language}}\n{{code}}\n```",
  variables: ["language", "focus", "code"]
}

list_prompts

List available prompt templates

{}

get_prompt

Retrieve and render prompts with variables

{
  id: "code-review",
  variables: {
    "language": "TypeScript",
    "focus": "performance",
    "code": "const result = await fetch('/api');"
  }
}

Architecture

┌─────────────────┐
│  Claude Desktop │ (MCP Client)
│                 │
└─────────┬───────┘
          │ JSON-RPC 2.0 via stdio
          │
┌─────────▼───────┐
│   MCP Server    │ (TypeScript/Node.js)
│                 │
├─────────────────┤
│ Domain Manager  │ (Project isolation)
│                 │  
├─────────────────┤
│ Fuse.js Search  │ (Fuzzy + pattern search)
│                 │
├─────────────────┤
│ SQLite Storage  │ (Resources + prompts)
│                 │
└─────────────────┘

Key Components

  • TypeScript/Node.js: Modern, maintainable codebase

  • SQLite: Reliable embedded database with ACID transactions

  • Fuse.js: Advanced fuzzy search with scoring and highlighting

  • Official MCP SDK: Anthropic's official Model Context Protocol implementation

  • Commander.js: Robust CLI interface with comprehensive options

  • Vitest: Modern testing framework with 76+ comprehensive tests

Token Optimization

MindPort is specifically optimized for AI interactions:

  • Compact Responses: Minimal formatting, maximum information density

  • Smart Truncation: Long content is intelligently summarized

  • Relevance Scoring: Results ranked by relevance to save tokens

  • Configurable Limits: Control response size with limit parameters

  • Context-Aware: Domain isolation reduces noise in search results

Search Capabilities

Fuzzy Search

# Finds "JavaScript Tutorial" even with typos
search_resources: "javascrpt tutorial"

Regex Patterns

# Find all function definitions
grep: "function\\s+\\w+\\("

# Find resources starting with "API"
find: "^API.*"

Tag-Based Filtering

# Exact tag matching
advanced_search: { query: "auth", tags: ["security"], exactTags: true }

# Partial tag matching  
advanced_search: { query: "auth", tags: ["sec"], exactTags: false }

Performance

Tested with 100+ resources:

  • Storage: < 10s for 100 resources

  • Indexing: < 1s for search index updates

  • Search: < 100ms for fuzzy search queries

  • Grep: < 100ms for regex pattern matching

  • Pagination: < 500ms for large result sets

Testing

Comprehensive test suite with 76 tests covering:

  • Storage Layer (17 tests): SQLite operations, CRUD, domain isolation

  • Search Engine (30 tests): Fuzzy search, patterns, grep, tag filtering

  • MCP Server (25 tests): All tools, error handling, tool schemas

  • Integration (4 tests): End-to-end workflows, performance, multi-domain

# Run all tests
npm test

# Run specific test suites
npm test storage
npm test search  
npm test server
npm test integration

Advanced Usage

Multi-Domain Workflow

# Create project domains
create_domain: { name: "frontend", description: "Frontend code and docs" }
create_domain: { name: "backend", description: "API and database" }

# Switch contexts
switch_domain: { domain: "frontend" }

# Store domain-specific resources
store_resource: { 
  name: "React Component", 
  content: "const Button = ...",
  tags: ["react", "component"]
}

Template-Driven Prompts

# Store template
store_prompt: {
  id: "bug-report",
  template: "Bug in {{component}}:\n**Expected:** {{expected}}\n**Actual:** {{actual}}"
}

# Use template
get_prompt: {
  id: "bug-report", 
  variables: { 
    component: "Login Form",
    expected: "User logged in",
    actual: "Error 401"
  }
}

Contributing

  1. Fork the repository

  2. Create a feature branch

  3. Write tests for new functionality

  4. Ensure all tests pass: npm run test:run

  5. Submit a pull request

License

MIT License - see LICENSE file for details.

Built for Claude Desktop | Optimized for AI Workflows | TypeScript + SQLite + Vitest

This server cannot be installed

F
license - not found
-
quality - not tested
D
maintenance

How are these scores calculated?

Maintenance

–Maintainers
–Response time
–Release cycle
–Releases (12mo)
Commit activity

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/jaenster/mcp-mindport'

If you have feedback or need assistance with the MCP directory API, please join our Discord server