# Cornelius Okeke Portfolio MCP Server

An MCP (Model Context Protocol) server that makes Cornelius Okeke's professional profile, experience, skills, projects, and portfolio information accessible to AI assistants.

The goal is to provide AI systems with a structured, machine-readable interface to professional portfolio data, allowing them to discover and retrieve relevant information through MCP tools.

## Overview

Traditional portfolios are designed primarily for human visitors. This project adds an **AI-accessible interface** to the portfolio.

Instead of relying on an AI assistant having the portfolio information in its context, an MCP-compatible client can query this server for relevant information.

```text
┌─────────────────────┐
│     AI Assistant    │
│  Claude / MCP Client│
└──────────┬──────────┘
           │
           │ MCP
           ▼
┌─────────────────────┐
│ Portfolio MCP Server│
│      NestJS         │
└──────────┬──────────┘
           │
     ┌─────┴──────┐
     ▼            ▼
 Portfolio     External
   Data        Services
```

## What is MCP?

[Model Context Protocol](https://modelcontextprotocol.io/) is an open protocol that allows AI applications to interact with external tools, resources, and data sources in a standardized way.

This server acts as an MCP interface for my professional portfolio.

An AI assistant can ask questions such as:

* What projects has Cornelius worked on?
* What technologies does he specialize in?
* What AI-related projects has he built?
* Tell me about his cloud experience.
* Show me projects involving TypeScript and AWS.
* What is his professional background?

The MCP server retrieves the relevant information and returns it to the AI client.

## Features

* 👤 Professional profile and background
* 💼 Professional experience
* 🛠️ Technical skills and technology stack
* 🚀 Portfolio projects
* 🤖 AI-related project information
* ☁️ Cloud and infrastructure experience
* 🔎 Project discovery and search
* 🔌 MCP-compatible interface
* 🏗️ Modular backend architecture
* ☁️ Designed for AWS serverless deployment

## Planned Architecture

The production architecture is designed around NestJS and AWS serverless infrastructure.

```text
                    ┌──────────────────┐
                    │    AI Client     │
                    │                  │
                    │ Claude / MCP App │
                    └────────┬─────────┘
                             │
                             │ MCP
                             ▼
                    ┌──────────────────┐
                    │   API Gateway    │
                    └────────┬─────────┘
                             │
                             ▼
                    ┌──────────────────┐
                    │   AWS Lambda     │
                    │                  │
                    │     NestJS       │
                    │       +          │
                    │   MCP SDK        │
                    └────────┬─────────┘
                             │
                  ┌──────────┼──────────┐
                  ▼          ▼          ▼
             ┌─────────┐ ┌────────┐ ┌─────────┐
             │DynamoDB │ │ GitHub │ │   S3    │
             │         │ │  API   │ │         │
             └─────────┘ └────────┘ └─────────┘
```

## MCP Capabilities

The server is intended to expose portfolio information through MCP tools such as:

| Tool                  | Description                               |
| --------------------- | ----------------------------------------- |
| `get_profile`         | Retrieve professional profile information |
| `get_experience`      | Retrieve professional experience          |
| `get_skills`          | Retrieve technical skills                 |
| `search_projects`     | Search portfolio projects                 |
| `get_project`         | Retrieve details about a specific project |
| `get_github_projects` | Retrieve relevant GitHub projects         |
| `get_contact_info`    | Retrieve professional contact information |

The exact tools and capabilities may evolve as the project develops.

## Technology Stack

### Backend

* [NestJS](https://nestjs.com/)
* TypeScript
* Node.js
* Model Context Protocol SDK

### AWS

* AWS Lambda
* Amazon API Gateway
* Amazon DynamoDB
* Amazon S3
* Amazon CloudWatch

### Development & Infrastructure

* Git
* GitHub
* AWS CDK / AWS SAM
* npm

## Project Structure

The project follows a modular NestJS architecture.

```text
src/
├── app.module.ts
│
├── mcp/
│   ├── mcp.module.ts
│   ├── mcp.controller.ts
│   └── mcp.service.ts
│
├── profile/
│   ├── profile.module.ts
│   └── profile.service.ts
│
├── projects/
│   ├── projects.module.ts
│   ├── projects.service.ts
│   └── projects.repository.ts
│
├── experience/
│   ├── experience.module.ts
│   └── experience.service.ts
│
└── github/
    ├── github.module.ts
    └── github.service.ts
```

The structure may change as the implementation evolves.

## Getting Started

### Prerequisites

Make sure you have:

* Node.js 20+
* npm
* Git

For AWS deployment:

* An AWS account
* AWS CLI
* Appropriate AWS credentials

### Installation

Clone the repository:

```bash
git clone https://github.com/comlyboy/corneliusokeke-portfolio-mcp-server.git
```

Change into the project directory:

```bash
cd corneliusokeke-portfolio-mcp-server
```

Install dependencies:

```bash
npm install
```

### Development

Start the development server:

```bash
npm run start:dev
```

### Build

```bash
npm run build
```

### Tests

```bash
npm test
```

## Configuration

Environment-specific configuration should be provided through environment variables.

Example:

```env
NODE_ENV=development

AWS_REGION=eu-west-1

GITHUB_API_URL=https://api.github.com
GITHUB_USERNAME=comlyboy
```

Do not commit secrets or credentials to the repository.

## Using the MCP Server

Once the server is running and configured with an MCP-compatible transport, an MCP client can connect to it and discover its available tools.

For example, an AI assistant could request:

```text
search_projects
{
  "query": "AI AWS"
}
```

The server can then return matching portfolio projects for the AI assistant to use in its response.

## Example Interaction

A user asks:

> What AI and cloud projects has Cornelius worked on?

The AI client can determine that portfolio information is required and invoke the appropriate MCP tool.

```text
AI Client
   │
   │ search_projects("AI cloud")
   ▼
MCP Server
   │
   │ Query portfolio data
   ▼
Portfolio Data
   │
   │ Matching projects
   ▼
MCP Server
   │
   │ Results
   ▼
AI Client
   │
   ▼
Natural language response
```

This keeps the portfolio data separate from the AI model while giving the model a standardized way to access it.

## Why MCP?

This project explores how professional portfolios can become **AI-native**.

A traditional portfolio primarily provides information to people through a web interface.

An MCP-enabled portfolio provides an additional interface:

```text
Human
  │
  ▼
Portfolio Website
```

and:

```text
AI Assistant
  │
  ▼
MCP
  │
  ▼
Portfolio Data
```

This allows the same professional information to be consumed by both humans and AI systems.

## Roadmap

* [x] Create project repository
* [ ] Initialize NestJS application
* [ ] Integrate MCP SDK
* [ ] Implement profile tools
* [ ] Implement project tools
* [ ] Implement experience tools
* [ ] Add project search
* [ ] Integrate GitHub API
* [ ] Add persistent portfolio data
* [ ] Add MCP HTTP transport
* [ ] Deploy to AWS Lambda
* [ ] Configure API Gateway
* [ ] Add authentication where appropriate
* [ ] Add CloudWatch observability
* [ ] Add automated tests
* [ ] Add CI/CD
* [ ] Connect to an MCP-compatible AI client

## Security

The server should never expose private information, credentials, API keys, or other sensitive data through MCP tools.

AWS credentials and other secrets should be supplied through environment configuration or AWS-managed secret mechanisms rather than committed to source control.

## About

**Cornelius Okeke** is a Senior Full-Stack Engineer with 7+ years of experience building scalable web applications, cloud-native SaaS platforms, and AI-powered solutions.

This project is part of my technical portfolio and demonstrates practical experience with:

* Full-stack engineering
* AI integration
* Model Context Protocol
* Backend architecture
* TypeScript
* NestJS
* AWS serverless architecture
* API design
* Cloud infrastructure

## Links

* Portfolio: https://okekecornelius.com
* GitHub: https://github.com/comlyboy
* Repository: https://github.com/comlyboy/corneliusokeke-portfolio-mcp-server

## License

This project is licensed under the MIT License.