MCP Servers Documentation

# MCP Servers Documentation

This document provides details about each of the Model Context Protocol (MCP) servers included in our docker-compose configuration, including their available tools and how to use them.

## Table of Contents
- [Slack MCP Server](#slack-mcp-server)
- [GitHub MCP Server](#github-mcp-server)
- [Context7 MCP Server](#context7-mcp-server)
- [MongoDB MCP Server](#mongodb-mcp-server)
- [Playwright MCP Server](#playwright-mcp-server)
- [Memory MCP Server](#memory-mcp-server)
- [Filesystem MCP Server](#filesystem-mcp-server)
- [Fetch MCP Server](#fetch-mcp-server)

## Slack MCP Server

**Image:** `mcp/slack-server:latest`  
**URL in local setup:** `http://slack-mcp-server:3000` (internal) or `http://localhost:3001` (external)

### Description
The Slack MCP Server provides tools for interacting with Slack workspaces, channels, and messages. It enables AI assistants to retrieve channel history, post messages, add reactions, and work with threads.

### Authentication
Requires a Slack OAuth token with appropriate scopes:
- `channels:history`
- `channels:read`
- `chat:write`
- `reactions:write`
- `users:read`

### Available Tools

#### Get Channel History
```json
{
  "toolName": "slack-mcp-server/slack_get_channel_history",
  "toolInput": {
    "channel_id": "C1234567890",
    "limit": 10
  }
}
```

#### Get Thread Replies
```json
{
  "toolName": "slack-mcp-server/slack_get_thread_replies",
  "toolInput": {
    "channel_id": "C1234567890",
    "thread_ts": "1234567890.123456"
  }
}
```

#### Post Message
```json
{
  "toolName": "slack-mcp-server/slack_post_message",
  "toolInput": {
    "channel_id": "C1234567890",
    "text": "Hello from MCP server!"
  }
}
```

#### Reply to Thread
```json
{
  "toolName": "slack-mcp-server/slack_reply_to_thread",
  "toolInput": {
    "channel_id": "C1234567890",
    "thread_ts": "1234567890.123456",
    "text": "This is a thread reply"
  }
}
```

#### Add Reaction
```json
{
  "toolName": "slack-mcp-server/slack_add_reaction",
  "toolInput": {
    "channel_id": "C1234567890",
    "timestamp": "1234567890.123456",
    "reaction": "thumbsup"
  }
}
```

#### List Channels
```json
{
  "toolName": "slack-mcp-server/slack_list_channels",
  "toolInput": {
    "limit": 100,
    "cursor": "optional_pagination_cursor"
  }
}
```

#### Get User Profile
```json
{
  "toolName": "slack-mcp-server/slack_get_user_profile",
  "toolInput": {
    "user_id": "U1234567890"
  }
}
```

#### Get Users
```json
{
  "toolName": "slack-mcp-server/slack_get_users",
  "toolInput": {
    "limit": 100,
    "cursor": "optional_pagination_cursor"
  }
}
```

## GitHub MCP Server

**Image:** `ghcr.io/github/github-mcp-server:latest`  
**URL in local setup:** `http://github-mcp-server:3000` (internal) or `http://localhost:3002` (external)

### Description
The GitHub MCP Server provides tools for interacting with GitHub repositories, including access to issues, pull requests, code, and more. It's designed to help AI assistants work with GitHub resources.

### Authentication
Requires a GitHub Personal Access Token (PAT) with appropriate permissions:
- For public repos: `public_repo`
- For private repos: `repo`
- Additional scopes might be needed depending on the specific operations

### Available Tools

#### Get Repository
```json
{
  "toolName": "github-mcp-server/get_repository",
  "toolInput": {
    "owner": "username",
    "name": "repo-name"
  }
}
```

#### List Issues
```json
{
  "toolName": "github-mcp-server/list_issues",
  "toolInput": {
    "owner": "username",
    "repo": "repo-name",
    "state": "open",
    "labels": ["bug", "enhancement"],
    "sort": "created",
    "direction": "desc",
    "page": 1,
    "perPage": 30
  }
}
```

#### Get Issue
```json
{
  "toolName": "github-mcp-server/get_issue",
  "toolInput": {
    "owner": "username",
    "repo": "repo-name",
    "issue_number": 42
  }
}
```

#### Create Issue
```json
{
  "toolName": "github-mcp-server/create_issue",
  "toolInput": {
    "owner": "username",
    "repo": "repo-name",
    "title": "Issue title",
    "body": "Issue description",
    "labels": ["bug"],
    "assignees": ["username"]
  }
}
```

#### Update Issue
```json
{
  "toolName": "github-mcp-server/update_issue",
  "toolInput": {
    "owner": "username",
    "repo": "repo-name",
    "issue_number": 42,
    "title": "Updated title",
    "body": "Updated description",
    "state": "closed",
    "labels": ["bug", "fixed"]
  }
}
```

#### Get File Contents
```json
{
  "toolName": "github-mcp-server/get_file_contents",
  "toolInput": {
    "owner": "username",
    "repo": "repo-name",
    "path": "src/main.js",
    "branch": "main"
  }
}
```

#### Create or Update File
```json
{
  "toolName": "github-mcp-server/create_or_update_file",
  "toolInput": {
    "owner": "username",
    "repo": "repo-name",
    "path": "src/main.js",
    "message": "Update main.js",
    "content": "Base64 encoded content",
    "branch": "feature-branch",
    "sha": "optional_file_sha_if_updating"
  }
}
```

#### Create Branch
```json
{
  "toolName": "github-mcp-server/create_branch",
  "toolInput": {
    "owner": "username",
    "repo": "repo-name",
    "branch": "new-feature",
    "from_branch": "main"
  }
}
```

#### Create Pull Request
```json
{
  "toolName": "github-mcp-server/create_pull_request",
  "toolInput": {
    "owner": "username",
    "repo": "repo-name",
    "title": "Add new feature",
    "body": "This PR adds a new feature",
    "head": "feature-branch",
    "base": "main"
  }
}
```

#### Get Pull Request
```json
{
  "toolName": "github-mcp-server/get_pull_request",
  "toolInput": {
    "owner": "username",
    "repo": "repo-name",
    "pullNumber": 42
  }
}
```

#### List Pull Requests
```json
{
  "toolName": "github-mcp-server/list_pull_requests",
  "toolInput": {
    "owner": "username",
    "repo": "repo-name",
    "state": "open",
    "sort": "created",
    "direction": "desc"
  }
}
```

#### Merge Pull Request
```json
{
  "toolName": "github-mcp-server/merge_pull_request",
  "toolInput": {
    "owner": "username",
    "repo": "repo-name",
    "pullNumber": 42,
    "merge_method": "merge"
  }
}
```

#### Search Repositories
```json
{
  "toolName": "github-mcp-server/search_repositories",
  "toolInput": {
    "query": "language:javascript stars:>1000",
    "page": 1,
    "perPage": 10
  }
}
```

#### Search Code
```json
{
  "toolName": "github-mcp-server/search_code",
  "toolInput": {
    "q": "function in:file language:javascript repo:user/repo",
    "page": 1,
    "perPage": 10
  }
}
```

## Context7 MCP Server

**Image:** `mcp/context7:latest`  
**URL in local setup:** `http://context7-mcp-server:3000` (internal) or `http://localhost:3004` (external)

### Description
The Context7 MCP Server provides context-aware tools for documentation, code search, package information, and other developer resources. It helps AI assistants provide accurate technical information.

### Available Tools

#### Get Library Documentation
```json
{
  "toolName": "context7-mcp-server/get-library-docs",
  "toolInput": {
    "context7CompatibleLibraryID": "/organization/project",
    "topic": "optional topic focus",
    "tokens": 10000
  }
}
```

#### Resolve Library ID
```json
{
  "toolName": "context7-mcp-server/resolve-library-id",
  "toolInput": {
    "libraryName": "react"
  }
}
```

#### Search GitHub Repository
```json
{
  "toolName": "context7-mcp-server/github_repo",
  "toolInput": {
    "repo": "facebook/react",
    "query": "useState hook implementation"
  }
}
```

#### Fetch Webpage
```json
{
  "toolName": "context7-mcp-server/fetch_webpage",
  "toolInput": {
    "urls": ["https://example.com/docs"],
    "query": "API reference"
  }
}
```

## MongoDB MCP Server

**Image:** `mcp/mongodb:latest`  
**URL in local setup:** `http://mongodb-mcp-server:3000` (internal) or `http://localhost:3005` (external)

### Description
The MongoDB MCP Server provides tools for interacting with MongoDB databases. It enables AI assistants to query, update, and manage MongoDB collections and documents.

### Authentication
Requires MongoDB connection details specified via environment variables or in the server configuration.

### Available Tools

#### Run MongoDB Query
```json
{
  "toolName": "mongodb-mcp-server/run_query",
  "toolInput": {
    "database": "mydb",
    "collection": "users",
    "operation": "find",
    "filter": {"age": {"$gt": 21}},
    "options": {"limit": 10, "sort": {"name": 1}}
  }
}
```

#### Insert Document
```json
{
  "toolName": "mongodb-mcp-server/insert_document",
  "toolInput": {
    "database": "mydb",
    "collection": "users",
    "document": {
      "name": "John Doe",
      "email": "[email protected]",
      "age": 30
    }
  }
}
```

#### Update Document
```json
{
  "toolName": "mongodb-mcp-server/update_document",
  "toolInput": {
    "database": "mydb",
    "collection": "users",
    "filter": {"_id": "objectid_here"},
    "update": {"$set": {"age": 31}},
    "options": {"upsert": false}
  }
}
```

#### Delete Document
```json
{
  "toolName": "mongodb-mcp-server/delete_document",
  "toolInput": {
    "database": "mydb",
    "collection": "users",
    "filter": {"email": "[email protected]"}
  }
}
```

#### List Collections
```json
{
  "toolName": "mongodb-mcp-server/list_collections",
  "toolInput": {
    "database": "mydb"
  }
}
```

#### Create Collection
```json
{
  "toolName": "mongodb-mcp-server/create_collection",
  "toolInput": {
    "database": "mydb",
    "collection": "new_collection",
    "options": {"capped": true, "size": 1000000}
  }
}
```

#### Aggregate
```json
{
  "toolName": "mongodb-mcp-server/aggregate",
  "toolInput": {
    "database": "mydb",
    "collection": "sales",
    "pipeline": [
      {"$match": {"status": "completed"}},
      {"$group": {"_id": "$customer", "total": {"$sum": "$amount"}}}
    ]
  }
}
```

## Playwright MCP Server

**Image:** `mcp/playwright:latest`  
**URL in local setup:** `http://playwright-mcp-server:3000` (internal) or `http://localhost:3006` (external)

### Description
The Playwright MCP Server provides tools for browser automation and web scraping. It enables AI assistants to interact with web pages, take screenshots, extract content, and perform automated testing.

### Available Tools

#### Navigate to Page
```json
{
  "toolName": "playwright-mcp-server/browser_navigate",
  "toolInput": {
    "session_id": "session_123",
    "url": "https://example.com"
  }
}
```

#### Click Element
```json
{
  "toolName": "playwright-mcp-server/browser_click",
  "toolInput": {
    "element": "Submit button",
    "ref": "button[type='submit']"
  }
}
```

#### Extract Content
```json
{
  "toolName": "playwright-mcp-server/smart_extract",
  "toolInput": {
    "url": "https://example.com",
    "extraction_goal": "product information and pricing"
  }
}
```

#### Browser Search
```json
{
  "toolName": "playwright-mcp-server/browser_search",
  "toolInput": {
    "query": "AI model comparison",
    "engine": "google",
    "num_results": 5
  }
}
```

## Memory MCP Server

**Image:** `mcp/memory:latest`  
**URL in local setup:** `http://memory-mcp-server:3000` (internal) or `http://localhost:3007` (external)

### Description
The Memory MCP Server provides persistent memory capabilities for AI assistants. It allows storing and retrieving context, conversation history, and user preferences across sessions.

### Available Tools

#### Store Memory
```json
{
  "toolName": "memory-mcp-server/store_memory",
  "toolInput": {
    "key": "user_preferences",
    "value": "User prefers TypeScript over JavaScript",
    "tags": ["preferences", "coding"]
  }
}
```

#### Retrieve Memory
```json
{
  "toolName": "memory-mcp-server/retrieve_memory",
  "toolInput": {
    "key": "user_preferences"
  }
}
```

#### Search Memory
```json
{
  "toolName": "memory-mcp-server/search_memory",
  "toolInput": {
    "query": "TypeScript preferences",
    "limit": 10
  }
}
```

## Filesystem MCP Server

**Image:** `mcp/filesystem:latest`  
**URL in local setup:** `http://filesystem-mcp-server:3000` (internal) or `http://localhost:3008` (external)

### Description
The Filesystem MCP Server provides file system operations for AI assistants. It enables reading, writing, and managing files and directories. This server has access to a shared workspace volume for GitHub repository content.

### Available Tools

#### Read File
```json
{
  "toolName": "filesystem-mcp-server/read_file",
  "toolInput": {
    "path": "/workspace/project/src/main.ts"
  }
}
```

#### Write File
```json
{
  "toolName": "filesystem-mcp-server/write_file",
  "toolInput": {
    "path": "/workspace/project/src/new-feature.ts",
    "content": "export const newFeature = () => { return 'Hello World'; };"
  }
}
```

#### List Directory
```json
{
  "toolName": "filesystem-mcp-server/list_directory",
  "toolInput": {
    "path": "/workspace/project/src"
  }
}
```

#### Create Directory
```json
{
  "toolName": "filesystem-mcp-server/create_directory",
  "toolInput": {
    "path": "/workspace/project/new-module"
  }
}
```

#### Delete File
```json
{
  "toolName": "filesystem-mcp-server/delete_file",
  "toolInput": {
    "path": "/workspace/project/old-file.js"
  }
}
```

## Fetch MCP Server

**Image:** `mcp/fetch:latest`  
**URL in local setup:** `http://fetch-mcp-server:3000` (internal) or `http://localhost:3009` (external)

### Description
The Fetch MCP Server provides HTTP request capabilities for AI assistants. It enables making GET, POST, PUT, DELETE, and other HTTP requests to external APIs and web services.

### Available Tools

#### HTTP GET Request
```json
{
  "toolName": "fetch-mcp-server/http_get",
  "toolInput": {
    "url": "https://api.github.com/user",
    "headers": {
      "Authorization": "token ghp_xxxxxxxxxxxx",
      "Accept": "application/vnd.github.v3+json"
    }
  }
}
```

#### HTTP POST Request
```json
{
  "toolName": "fetch-mcp-server/http_post",
  "toolInput": {
    "url": "https://api.example.com/data",
    "headers": {
      "Content-Type": "application/json"
    },
    "body": {
      "name": "example",
      "value": "test"
    }
  }
}
```

#### Fetch Webpage Content
```json
{
  "toolName": "fetch-mcp-server/fetch_webpage",
  "toolInput": {
    "url": "https://example.com/docs",
    "extract_text": true,
    "follow_redirects": true
  }
}
```

## MCP Server Configuration

### Port Mapping
The following ports are configured for external access:
- **Slack MCP Server**: localhost:3001
- **GitHub MCP Server**: localhost:3002  
- **Context7 MCP Server**: localhost:3004
- **MongoDB MCP Server**: localhost:3005
- **Playwright MCP Server**: localhost:3006
- **Memory MCP Server**: localhost:3007
- **Filesystem MCP Server**: localhost:3008
- **Fetch MCP Server**: localhost:3009

### Shared Workspace
The Filesystem MCP Server has access to a shared workspace volume (`/workspace`) that can be used to:
- Store cloned GitHub repositories
- Share files between different MCP servers
- Persist file changes across container restarts
- Enable collaborative file operations between the React app and MCP servers