Content
# 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:
```bash
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:
```bash
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:
```bash
dart bin/stdio_server.dart
```
#### Configuring Claude Desktop
To use the MCP server with Claude Desktop, add the following to your Claude configuration:
```json
{
"mcpServers": {
"me_mcp": {
"command": "dart",
"args": [
"path/to/bin/stdio_server.dart"
]
}
}
}
```
Alternatively, you can compile the server to a standalone executable:
```bash
dart compile exe bin/stdio_server.dart -o ./mcp_server
```
And then configure Claude Desktop to use the compiled version:
```json
{
"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:
| Variable | Description | Default |
|----------|-------------|---------|
| HOST | Host address to bind to | 0.0.0.0 |
| PORT | Port to listen on | 3000 |
| ENVIRONMENT | Environment (development, production) | development |
### YAML Configuration
Personal information and job search preferences are configured through the `me.yaml` file.
#### Initializing Configuration
To create a default configuration file:
```bash
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
```yaml
# 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
| Section | Option | Description | Default |
|---------|--------|-------------|---------|
| - | name | Your profile/candidate name | Jane Smith |
| - | resume_url | URL to the resume | https://example.com/resume.pdf |
| - | linkedin_url | URL to LinkedIn profile | https://linkedin.com/in/example |
| - | github_url | URL to GitHub profile | https://github.com/example |
| - | website_url | URL to personal website | https://example.com |
| - | resume_text | Full text content of the resume | An empty resume. |
| job_search | min_salary | Minimum salary for job search | 100000 |
| job_search | max_salary | Maximum salary for job search | 500000 |
| job_search | location | Preferred job location | Remote |
| job_search | company_type | Preferred company type | Startup |
| job_search | industry | Preferred industry | Technology |
| job_search | description | Additional job search details | "" |
### Type-Safe Configuration (For Developers)
The YAML configuration is parsed into strongly-typed Dart objects:
```dart
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
```bash
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
```bash
docker build -t jhgaylor/me-mcp-server:local .
```
### Running the Docker Image
```bash
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**:
```bash
-v $(pwd)/me.yaml:/app/me.yaml
```
2. **Set environment variables**:
```bash
-e HOST=0.0.0.0 -e PORT=3000 -e ENVIRONMENT=production
```
3. **Use docker-compose.yml**:
```yaml
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](https://github.com/jhgaylor/jakegaylor-com-mcp-server)
