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.

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

Related MCP server: personal-context

What is MCP?

Model Context Protocol 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.

                    ┌──────────────────┐
                    │    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:

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

Technology Stack

Backend

• NestJS

• 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.

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:

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

Change into the project directory:

cd corneliusokeke-portfolio-mcp-server

Install dependencies:

npm install

Development

Start the development server:

npm run start:dev

Build

npm run build

Tests

npm test

Configuration

Environment-specific configuration should be provided through environment variables.

Example:

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:

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.

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:

Human
  │
  ▼
Portfolio Website

and:

AI Assistant
  │
  ▼
MCP
  │
  ▼
Portfolio Data

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

Roadmap

• 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.