me_mcp_server

Me MCP Server

A MCP (Model Context Protocol) server for learning about and interacting with YOU.

Features

This MCP server provides the following capabilities:

Prompts

• JobSearch - Generate job search instructions tailored to your profile with specified salary range, location, and company type preferences.

Resources

• Resume Text - Access your full resume text (candidate-info://resume)
• Resume URL - Get the URL to your resume PDF (candidate-info://resume-url)
• LinkedIn Profile URL - Access your LinkedIn profile (candidate-info://linkedin-url)
• GitHub Profile URL - Access your GitHub profile (candidate-info://github-url)
• Website URL - Get your personal website URL (candidate-info://website-url)
• Website Contents - Fetch and analyze the HTML contents of your website (candidate-info://website-contents)

Running the server

Using Docker

The easiest way to run the server is using Docker Compose:

docker-compose up -d

This will start the server on port 3000.

Transport Options

This MCP server supports two different transport mechanisms:

SSE (Server-Sent Events) Transport

The SSE transport allows the server to communicate over HTTP with clients that support server-sent events. This is useful for web-based clients or any client that can establish an HTTP connection.

To run the server with SSE transport:

dart bin/sse_server.dart

The SSE server will start on the configured host and port (default: 0.0.0.0:3000).

Stdio Transport

The Stdio transport uses standard input/output streams for communication. This is ideal for integration with desktop clients like Claude Desktop that launch the MCP server as a subprocess.

To run the server with Stdio transport:

dart bin/stdio_server.dart

Configuring Claude Desktop

To use the MCP server with Claude Desktop, add the following to your Claude configuration:

{
  "mcpServers": {
    "me_mcp": {
      "command": "dart",
      "args": [
        "path/to/bin/stdio_server.dart"
      ]
    }
  }
}

Alternatively, you can compile the server to a standalone executable:

dart compile exe bin/stdio_server.dart -o ./mcp_server

And then configure Claude Desktop to use the compiled version:

{
  "mcpServers": {
    "me_mcp": {
      "command": "path/to/mcp_server"
    }
  }
}

Configuration

The server uses a hybrid configuration approach:

1. Server settings - Configured using environment variables
2. Personal information - Configured using a me.yaml file

Environment Variables

Server-related settings are configured through environment variables:

YAML Configuration

Personal information and job search preferences are configured through the me.yaml file.

Initializing Configuration

To create a default configuration file:

dart bin/me_init.dart [path]

This will generate a me.yaml file (or at the specified path) with default values that you can edit.

Example Configuration

# Personal information
name: Jake Gaylor
resume_url: https://example.com/resume.pdf
website_url: https://jakegaylor.com
linkedin_url: https://linkedin.com/in/jakegaylor
github_url: https://github.com/jhgaylor

# Optional content (can be loaded from URLs above if not specified)
resume_text: |
  Jake Gaylor
  Software Engineer

  Experience:
  - Example Company (2020-Present)
    Senior Software Engineer
  
  Skills:
  - Dart, JavaScript, TypeScript
  - Cloud Infrastructure

website_text: ""  # Will be fetched from website_url if empty

# Job search preferences
job_search:
  min_salary: 150000
  max_salary: 250000
  location: Remote
  company_type: Startup
  industry: Technology
  description: "Looking for senior engineering roles with focus on cloud infrastructure"

YAML Configuration Options

Type-Safe Configuration (For Developers)

The YAML configuration is parsed into strongly-typed Dart objects:

import 'package:me_mcp_server/me_mcp_server.dart';

// Create a configuration programmatically
final config = MeConfig(
  name: 'Jane Smith',
  resumeUrl: 'https://example.com/resume.pdf',
  jobSearch: JobSearchConfig(
    minSalary: 150000,
    maxSalary: 250000,
    location: 'Remote',
  ),
);

// Convert to YAML
final yamlString = configToYaml(config);

Running Locally

To run the server locally:

1. Ensure you have Dart SDK 3.7.2 or later installed
2. Install dependencies: dart pub get
3. Create a me.yaml file in the root directory with your configuration

   dart bin/me_init.dart
   

4. Set any environment variables as needed
5. Run the server with your preferred transport:
   • SSE: dart bin/sse_server.dart
   • Stdio: dart bin/stdio_server.dart

Development

Building the Docker Image

docker build -t jhgaylor/me-mcp-server:local .

Running the Docker Image

docker run -p 3000:3000 \
  -v $(pwd)/me.yaml:/app/me.yaml \
  -e PORT=3000 \
  -e ENVIRONMENT=production \
  jhgaylor/me-mcp-server:local

Docker Configuration

When using Docker, you can:

1. Mount your me.yaml file:

   -v $(pwd)/me.yaml:/app/me.yaml
   

2. Set environment variables:

   -e HOST=0.0.0.0 -e PORT=3000 -e ENVIRONMENT=production
   

3. Use docker-compose.yml:

   services:
     mcp-server:
       volumes:
         - ./me.yaml:/app/me.yaml
       environment:
         - HOST=0.0.0.0
         - PORT=3000
         - ENVIRONMENT=production
   

Deployment Examples

Deploying to a Custom Domain

You can deploy this MCP server to your own domain. Here's an example of a deployment that runs at mcp.jakegaylor.com:

• GitHub Repository: jhgaylor/jakegaylor-com-mcp-server