Gomcptest

This project is a proof-of-concept (POC) that demonstrates how to implement the Model Context Protocol (MCP) through a custom host for testing agentic systems. Core features include OpenAI-compatible API, Google Gemini integration, streaming response support, and tool invocation capabilities.

Developer tools Artificial intelligence chatbots #Model Protocol #Agentic System #Gemini Integration #Tool Invocation .Go

rating : 2.5 points

downloads : 8.1K

update time : 2025-04-29

Open Site

What is gomcptest?

gomcptest is an experimental platform that allows developers to test and prototype agentic systems using the Model Context Protocol (MCP). It provides a custom-built host that mimics the OpenAI API while actually using Google's Gemini models through Vertex AI.

How to use gomcptest?

The system consists of a custom host server and various tools that can be combined to create specialized agents. You can build the tools, configure the environment, and then interact with them through the CLI or API interface.

Use Cases

Ideal for developing and testing specialized AI agents for code scanning, security analysis, automated documentation, data processing, and other developer productivity tools.

Key Features

OpenAI API Compatibility

Supports the OpenAI v1 chat completion format for easy integration with existing tools

Google Gemini Integration

Uses VertexAI API to interact with Google's Gemini models

Streaming Support

Provides real-time streaming responses for better user experience

Function Calling

Allows models to call external functions and incorporate results

MCP Tool Integration

Works with various MCP-compatible tools (Bash, File Editing, Grep, etc.)

Advantages

Flexible testing environment for agentic systems

OpenAI-compatible API makes integration easy

Supports multiple powerful tools out of the box

Streaming responses enable real-time interaction

Limitations

Proof-of-concept quality (not production-ready)

Requires Google Cloud Platform access

Potential security risks from tool execution

Limited documentation as an experimental project

Getting Started

Install Prerequisites

Ensure you have Go 1.21+ installed and GCP access configured

Build Tools

Compile all the necessary tools using the provided Makefile

Configure Environment

Set up required environment variables in .envrc

Start Server

Run the openaiserver to begin testing

Test with CLI

Use the provided CLI to interact with the system

Example Use Cases

Code Security Scanning

Create an agent that scans code repositories for potential security vulnerabilities

Automated Documentation

Generate comprehensive documentation from source code

Data Analysis

Process and visualize complex datasets

Frequently Asked Questions

Is this production-ready?

What safety precautions should I take?

Can I use models other than Gemini?

How do I add new tools?

Additional Resources

Project Documentation

Auto-generated project documentation

Google Vertex AI

Information about Google's Vertex AI service

Model Context Protocol

MCP protocol implementation

🚀 gomcptest: A Proof-of-Concept Project for Implementing MCP with Custom Host

This project is a proof-of-concept (POC) demonstrating how to implement the Model Context Protocol (MCP) through a custom-built host and interact with an agentized system. The code is written from scratch to provide a clear understanding of the underlying mechanisms.

View the auto-generated documentation on the experimental website: https://owulveryck.github.io/gomcptest/

🚀 Quick Start

Goals

The primary goal of this project is to achieve security, maintainability, and efficiency of the codebase through the Model Context Protocol (MCP). For example:

The dispatch_agent can be specialized to scan for security vulnerabilities in the codebase.
A code review agent can be created to analyze potential issues in pull requests.
A data analysis agent can be built to process and visualize complex datasets.
An auto-documentation agent can be developed to generate comprehensive documentation based on the code.

These specialized agents can be easily tested and iterated upon using the tools provided in this repository.

Prerequisites

Go language version >= 1.21
Access to the Google Cloud Platform (GCP) Vertex AI API
github.com/mark3labs/mcp-go

The tool uses the default GCP login credentials configured with gcloud auth login.

Project Structure

Architecture Diagram

host/openaiserver: Implements a custom host that mimics the OpenAI API, using Google Gemini and function calls. This is the core of the POC.
tools: Contains multiple MCP-compatible tools that can interact with the host:
- dispatch-agent: Handles the functionality of the agentized system.
- transformer: Implements a text generation model similar to GPT-3.
- image-generator: Generates images using the Imagen series of models.

Features

Host	Endpoint	Description
OpenAI	`api/v1/chat/completions`	Mimics the OpenAI API, supporting text-based interactive chat and function calls
GPT-3	`api/v1/gpt-3`	Provides an interface compatible with GPT-3
Image Generator	`api/v1/image-generator`	Generates images using the Imagen series of models

Building the Tools

To build the project, run the following commands:

go mod tidy
make build

Configuration

Global Configuration

Property	Details	Default Value	Required
`PORT`	Server listening port	`8080`	No
`LOG_LEVEL`	Log level (DEBUG, INFO, WARN, ERROR)	`INFO`	No
`IMAGE_DIR`	Directory to store images	-	Yes

GCP Configuration

Property	Details	Default Value	Required
`GCP_PROJECT`	Google Cloud Project ID	-	Yes
`GEMINI_MODELS`	Comma-separated list of Gemini models	`gemini-1.5-pro,gemini-2.0-flash`	No
`GCP_REGION`	Google Cloud Region	`us-central1`	No
`IMAGEN_MODELS`	Comma-separated list of Imagen models	-	No
`IMAGE_DIR`	Directory to store images	-	Yes

Important Note

This project is a proof-of-concept and has certain limitations.
The code is provided as-is and is intended for educational purposes only to understand how to implement MCP with a custom host.