Analyzes local git diffs to understand code changes and automatically generate descriptive commit messages.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Git Commit Message Generator MCP Server generate a conventional commit message for my staged changes"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An intelligent MCP server that automatically generates Conventional Commits style commit messages using LLM providers like DeepSeek and Groq.
AI-Powered: Leverages LLM providers (DeepSeek, Groq) for intelligent commit message generation
Conventional Commits: Follows industry-standard commit message conventions
Multi-Provider: Supports multiple LLM providers with easy switching
MCP Compatible: Works seamlessly with Claude, Cursor, Gemini CLI, and other MCP clients
Easy Setup: Simple configuration via environment variables
Related MCP server: Cursor Auto-Review MCP Server
Clone and install:
git clone https://github.com/FradSer/mcp-server-git-cz.git
cd mcp-server-git-cz
uv venv && uv pip install -r requirements.txtConfigure environment:
cp .env.example .env
# Edit .env with your API keysRun the server:
uv run mcp-server-git-czuv package manager
Clone the repository:
git clone https://github.com/FradSer/mcp-server-git-cz.git
cd mcp-server-git-czCreate virtual environment and install dependencies:
uv venv
uv pip install -r requirements.txtSet up environment variables:
cp .env.example .envEdit .env file:
DEEPSEEK_API_KEY=your_deepseek_api_key
GROQ_API_KEY=your_groq_api_key
LLM_PROVIDER=deepseek # or groqVariable | Description | Default | Required |
| DeepSeek API key | - | Yes (if using DeepSeek) |
| Groq API key | - | Yes (if using Groq) |
| LLM provider to use |
| No |
The server supports multiple transport methods:
# STDIO transport (recommended)
uv run mcp-server-git-cz
# SSE transport
uv run mcp-server-git-cz --transport sse --port 8000The server exposes a single tool: generate_commit_message that analyzes your git diff and generates conventional commit messages.
import asyncio
from mcp.client.session import ClientSession
from mcp.client.stdio import StdioServerParameters, stdio_client
async def main():
async with stdio_client(
StdioServerParameters(command="uv", args=["run", "mcp-server-git-cz"])
) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
# Generate commit message
result = await session.call_tool("generate_commit_message", {})
print(result)
asyncio.run(main())Note: Replace
/path/to/mcp-server-git-czwith your actual project directory path in all configurations below.
# Project scope (recommended for teams)
claude mcp add git-cz -s project -- uv run --python /path/to/mcp-server-git-cz/.venv/bin/python -m mcp_server_git_cz
# User scope (personal use)
claude mcp add git-cz -s user -- uv run --python /path/to/mcp-server-git-cz/.venv/bin/python -m mcp_server_git_czAdd to Cursor settings:
{
"mcpServers": {
"git-cz": {
"command": "uv",
"args": ["run", "--python", "/path/to/mcp-server-git-cz/.venv/bin/python", "-m", "mcp_server_git_cz"],
"env": {},
"transport": "stdio"
}
}
}Add to ~/.gemini/settings.json:
{
"mcpServers": {
"git-cz": {
"command": "uv",
"args": ["run", "--python", "/path/to/mcp-server-git-cz/.venv/bin/python", "-m", "mcp_server_git_cz"],
"env": {}
}
}
}Get virtual environment path:
cd mcp-server-git-cz
uv venv
which python # Copy this pathGet project directory:
pwd # Copy this pathUpdate configurations with your actual paths
{
"mcpServers": {
"git-cz": {
"command": "uv",
"args": ["run", "--python", "/path/to/mcp-server-git-cz/.venv/bin/python", "-m", "mcp_server_git_cz"],
"env": {
"DEEPSEEK_API_KEY": "your_key_here",
"LLM_PROVIDER": "deepseek"
}
}
}
}{
"mcpServers": {
"git-cz": {
"command": "uv",
"args": ["run", "--python", "/path/to/mcp-server-git-cz/.venv/bin/python", "-m", "mcp_server_git_cz"],
"cwd": "/path/to/mcp-server-git-cz",
"env": {}
}
}
}Once configured, you can interact with the tool using natural language:
"Generate a commit message for my current changes"
"Create a conventional commit message based on my git diff"
"Help me write a commit message following conventional commits"
The server will:
Analyze your current git diff
Generate a conventional commit message using AI
Return the formatted message for review
feat(auth): add OAuth2 integration with GitHub
- Implement OAuth2 authentication flow
- Add GitHub provider configuration
- Update user model to support external auth
- Add tests for authentication endpoints
Closes #123We welcome contributions! Please follow these guidelines:
Fork the repository
Create a feature branch: git checkout -b feature/amazing-feature
Make your changes
Run tests: make test
Commit using conventional commits: git commit -m 'feat: add amazing feature'
Push to your branch: git push origin feature/amazing-feature
Open a Pull Request
Follow PEP 8 for Python code
Use Black for code formatting
Add type hints where appropriate
Write tests for new features
Found a bug? Have a feature request? Please open an issue with:
Clear description of the problem
Steps to reproduce
Expected vs actual behavior
Environment details
This project is licensed under the MIT License - see the LICENSE file for details.
Documentation: Full documentation
Bug Reports: GitHub Issues
Feature Requests: GitHub Discussions
Email: fradser@gmail.com
Conventional Commits specification
Model Context Protocol framework
All contributors who help improve this project
Generate a commit message from the git changes in the current project directory.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool generates a commit message but does not describe how it works (e.g., whether it uses AI, templates, or summaries), what output format to expect, or any constraints (e.g., error handling if no git changes exist). This leaves significant gaps in understanding the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that directly states the tool's function without redundancy. It is front-loaded with the core action and includes essential context (git changes, current directory). There is no wasted verbiage, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but has gaps. It explains what the tool does but lacks details on behavior, output, or error conditions. Without annotations or output schema, the description should provide more context to be fully complete, but it meets minimum viability for a basic tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description appropriately does not discuss parameters, which is efficient. A baseline score of 4 is applied for zero parameters, as it avoids unnecessary detail while matching the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate a commit message from the git changes in the current project directory.' It specifies the verb ('generate') and resource ('commit message'), and explains the source of input ('git changes in the current project directory'). However, since there are no sibling tools, it cannot differentiate from alternatives, preventing a score of 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., being in a git repository), exclusions, or contextual cues. The absence of sibling tools means no explicit alternatives are named, but the description still lacks usage context beyond the basic operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
With only one tool, there is no possibility of ambiguity or overlap between tools. The tool's purpose is clearly defined and distinct by default.
The single tool name follows a clear verb_noun pattern (generate_commit_message), which is consistent and predictable. There are no other tools to compare against, so no inconsistency exists.
One tool is too few for a server's purpose, as it limits functionality and suggests a narrow scope that might not support complex workflows. Typically, a well-scoped server would have 3-15 tools to cover a domain adequately.
The server is severely incomplete for generating commit messages, as it only offers generation without supporting operations like customization, validation, history management, or integration with other git tasks. This creates significant gaps for agent workflows.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
A MCP server built for developers enabling Git based project management with project and personal…
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
An MCP server that gives your AI access to the source code and docs of all public github repos
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/FradSer/mcp-server-git-cz'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
