AI Developer Workspace — MCP Project

An AI-powered developer workspace built using the Model Context Protocol (MCP). The project allows developers to inspect and modify a local software project through a web interface and an AI coding agent.

The system combines FastMCP, FastAPI, Groq, Git, and a browser-based frontend to create a lightweight AI development assistant.

🚀 Overview

AI Developer Workspace acts as a mini AI coding assistant that can understand a developer's request and perform project-level operations through MCP tools.

Instead of manually navigating through project files, developers can use the workspace to:

• View project files

• Read source files

• Search project files

• Create new files

• Update existing files

• Delete files

• Check Git status

• View recent Git commits

• Generate a project summary

• Ask an AI agent to perform development tasks

The AI agent uses MCP tools to interact with the project rather than directly modifying files.

Related MCP server: file-extractor-mcp

✨ Features

📁 Project File Management

The workspace provides tools for:

• Listing project files

• Reading files

• Searching files by keyword

• Creating files

• Updating existing files

• Deleting files

🤖 AI Developer Agent

The AI agent accepts natural-language development requests such as:

Create calculator.py with add, subtract, multiply and divide functions.

or:

Update calculator.py to add power and modulus functions while preserving the existing functionality.

The agent determines whether it needs to create or update a file and invokes the appropriate MCP tool.

🔌 Model Context Protocol

The project uses FastMCP to expose developer operations as MCP tools.

The AI agent communicates with the MCP server using the MCP client.

Example architecture:

User
  │
  ▼
Web Frontend
  │
  │ HTTP
  ▼
FastAPI Backend
  │
  ├── Project APIs
  │
  └── AI Agent
        │
        │ Groq LLM
        ▼
      Tool Calling
        │
        ▼
     MCP Client
        │
        ▼
     FastMCP Server
        │
        ├── create_file
        ├── update_file
        ├── read_file
        ├── delete_file
        ├── search_files
        └── Git operations

🌿 Git Integration

The workspace can inspect the project's Git repository and expose information such as:

• Current Git status

• Modified files

• Recent commits

• Commit information

📊 Project Summary

The application can generate a project-level summary containing information about the project and recent development activity.

🌐 Web Interface

A lightweight browser frontend provides an interface for interacting with the backend.

The frontend communicates with the FastAPI server using HTTP requests.

🛠️ Technology Stack

📂 Project Structure

mini-devpilot/
│
├── server.py
│
├── demo_client/
│   ├── index.html
│   ├── app.js
│   └── style.css
│
├── .env
├── requirements.txt
│
└── project files/

The exact structure may vary depending on the current development version.

⚙️ Setup

1. Clone the repository

git clone https://github.com/Praniti1594/MCP-project-ai-developer-workspace.git
cd MCP-project-ai-developer-workspace

2. Create a virtual environment

Windows:

python -m venv .venv

Activate it:

.\.venv\Scripts\Activate.ps1

3. Install dependencies

pip install -r requirements.txt

4. Configure environment variables

Create a .env file:

GROQ_API_KEY=your_groq_api_key
GROQ_MODEL=llama-3.3-70b-versatile

Never commit your .env file or API keys to GitHub.

▶️ Running the Backend

From the project root:

python server.py

The backend runs on:

http://127.0.0.1:9000

▶️ Running the Frontend

Open another terminal:

cd demo_client
python -m http.server 5500

Then open:

http://127.0.0.1:5500

The frontend communicates with the backend at:

http://127.0.0.1:9000

🔧 Example AI Requests

Create a file

Create calculator.py with functions for addition, subtraction,
multiplication and division.

Update a file

Update calculator.py to add power and modulus functions while
preserving all existing functionality.

Project inspection

Show me the project files.

Search the project for the word "stack".

Read dsa.py.

🔗 API Endpoints

The backend exposes endpoints for common developer workspace operations.

🧠 AI Agent Workflow

When the user sends a development request:

User Request
     │
     ▼
AI Agent
     │
     ├── Create new file?
     │       │
     │       └── create_file
     │
     └── Modify existing file?
             │
             ├── Read existing file
             │
             └── update_file

For updates, the agent retrieves the existing file contents before generating the updated version. This helps preserve existing functionality instead of blindly replacing a file.

🔐 Security Considerations

• API keys are stored in environment variables.

• .env should not be committed to Git.

• File operations should be restricted to the intended project workspace.

• The MCP server should not be exposed publicly without appropriate authentication and access controls.

🎯 Project Goals

This project was created to explore how Model Context Protocol can be used to build AI-powered developer tools.

The main goals are:

1. Understand MCP server and client architecture.

2. Build practical developer tools using MCP.

3. Connect an LLM to MCP tools through function/tool calling.

4. Allow an AI agent to interact with real project files.

5. Integrate Git information into an AI developer workspace.

6. Build a usable browser-based developer interface.

🔮 Future Improvements

Potential improvements include:

• Streaming AI responses

• Webhooks and event handlers

• Better error handling

• Authentication and authorization

• File-diff previews before applying changes

• Undo/rollback for file modifications

• Git commit creation through the AI agent

• Automated tests

• Code validation before writing files

• Syntax checking after AI-generated changes

• Improved MCP tool discovery

• Better frontend error handling

• Agent execution history

• Tool-call logging and monitoring

📚 What This Project Demonstrates

This project demonstrates practical experience with:

• Model Context Protocol (MCP)

• MCP tool design

• FastMCP

• AI tool calling

• LLM agents

• FastAPI

• REST APIs

• Asynchronous Python

• Git integration

• Frontend/backend communication

• Environment configuration

• AI-assisted software development

👩‍💻 Author

Praniti Kubal

GitHub:

https://github.com/Praniti1594