LangGraph Coding Team

by danmas0n

23 stars

Not rated

GitHub

About

Create coding agents to generate implementation options.

Details

Author: danmas0n
Repository: danmas0n/multi-agent-with-mcp
GitHub stars: 23
License: MIT License
Categories: Design, Workplace, Developer Tools, Communication, Project Management, Frontend
Tags: #visualization

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below
Plugin Name LangGraph Coding Team

Command (node, npx, python, etc.) npx
Arguments
- Argument 1 -y
- Argument 2 @modelcontextprotocol/server-filesystem
- Argument 3 /path/to/directory
Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "npx"
        }
    }
}

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "/c",
                "npx",
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "npx"
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "npx"
        }
    }
}

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "/c",
                "npx",
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "npx"
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "npx"
        }
    }
}

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "/c",
                "npx",
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "npx"
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "npx"
        }
    }
}

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "/c",
                "npx",
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "npx"
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "npx"
        }
    }
}

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "/c",
                "npx",
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "npx"
        }
    }
}

From the repository

pip install -e .

cd gateway pip install -e . cd ..

The agent supports multiple LLM providers through environment variables:

LLM_MODEL=provider/model-name

OPENROUTER_BASE_URL=https://openrouter.ai/api/v1

The gateway server is configured through gateway/config.json. By default, it starts two MCP servers:

{
  "mcp": {
    "servers": {
      "filesystem": {
        "command": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-filesystem",
          "/path/to/directory"
        ]
      },
      "memory": {
        "command": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-memory"
        ]
      }
    }
  }
}

You can add more servers from the official MCP servers repository.

The agent's connection to the gateway is configured in langgraph.json:

{
  "dependencies": ["."],
  "graphs": {
    "agent": "./src/react_agent/graph.py:graph"
  },
  "env": ".env",
  "mcp": {
    "gateway_url": "http://localhost:8808"
  }
}

`read_file`

Read file contents.

`write_file`

Create or update files.

`list_directory`

List directory contents.

`search_files`

Find files matching patterns.

`create_entities`

Add entities to knowledge graph.

`create_relations`

Link entities together.

`search_nodes`

Query the knowledge graph.

The agent has access to tools from both MCP servers:

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "langgraph coding team": {
            "cwd": "gateway",
            "env": {},
            "args": [
                "-y",
                "@modelcontextprotocol/server-filesystem",
                "/path/to/directory"
            ],
            "command": "npx"
        }
    }
}

Linux

{
    "cwd": "gateway",
    "env": [],
    "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/directory"
    ],
    "command": "npx"
}

Macos

{
    "cwd": "gateway",
    "env": [],
    "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/directory"
    ],
    "command": "npx"
}

Windows

{
    "cwd": "gateway",
    "env": [],
    "args": [
        "/c",
        "npx",
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/directory"
    ],
    "command": "cmd"
}

LangGraph Coding Agent Team with MCP

This project implements a small team of coding agents using LangGraph and the Model Context Protocol (MCP). The agents use MCP servers to provide tools and capabilities through a unified gateway.

The overall objective of this agent team is to take requirements and code context and create multiple implementations of proposed features; human operators can then choose their preferred approach and proceed, discarding the others.

This project originated from the Anthropic MCP Hackathon in NYC on 12/11/2024 and has since evolved into its own standalone project.

Architecture

The system consists of three main components:

1. MCP Gateway Server: A server that:
- Manages multiple MCP server processes
- Provides a unified API for accessing tools
- Handles communication with MCP servers
- Exposes tools through a simple HTTP interface

2. MCP Servers: Individual servers that provide specific capabilities:
- GitHub Server: Repo operations (read, write, list, search, create branch, create PR, etc.)
- Additional servers can be added for more capabilities

3. Coding Agents: There are three agents that collaborate to accomplish coding tasks:
- Orchestrator: Gathers context from human messages and uses MCP servers to access Linear and GitHub. Delegates to planner and coder as needed.
- Planner: Takes requirements and code context and creates a plan with multiple implementation suggestions. Does not use MCP.
- Coder: Takes code context and proposed implementations and implements all of them on separate GitHub branches.

Getting Started

1. Install Dependencies

# Install the agent package
pip install -e .
Install the gateway package
cd gateway
pip install -e .
cd ..

2. Configure Environment Variables

The agent supports multiple LLM providers through environment variables:

# LLM Configuration - supports multiple providers:
LLM_MODEL=provider/model-name
Supported providers and example models:
- Anthropic: anthropic/claude-3-5-sonnet-20240620
- OpenAI: openai/gpt-4
- OpenRouter: openrouter/openai/gpt-4o-mini
- Google: google/gemini-1.5-pro
API Keys for different providers
OPENAI_API_KEY=your_openai_api_key
ANTHROPIC_API_KEY=your_anthropic_api_key
OPENROUTER_API_KEY=your_openrouter_api_key
GOOGLE_API_KEY=your_google_api_key
OpenRouter Configuration (if using OpenRouter)
OPENROUTER_BASE_URL=https://openrouter.ai/api/v1

3. Configure MCP Servers

The gateway server is configured through gateway/config.json. By default, it starts two MCP servers:

{
  "mcp": {
    "servers": {
      "filesystem": {
        "command": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-filesystem",
          "/path/to/directory"
        ]
      },
      "memory": {
        "command": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-memory"
        ]
      }
    }
  }
}

You can add more servers from the official MCP servers repository.

4. Start the Gateway Server

cd gateway
python -m mcp_gateway.server

The server will start on port 8808 by default.

5. Configure the Agent

The agent's connection to the gateway is configured in langgraph.json:

{
  "dependencies": ["."],
  "graphs": {
    "agent": "./src/react_agent/graph.py:graph"
  },
  "env": ".env",
  "mcp": {
    "gateway_url": "http://localhost:8808"
  }
}

6. Use the Agent

Open the folder in LangGraph Studio! The agent will automatically:
1. Connect to the gateway server
2. Discover available tools
3. Make tools available for use in conversations

Available Tools

The agent has access to tools from both MCP servers:

Filesystem Tools

- read_file: Read file contents - write_file: Create or update files - list_directory: List directory contents - search_files: Find files matching patterns - And more...

Memory Tools

- create_entities: Add entities to knowledge graph - create_relations: Link entities together - search_nodes: Query the knowledge graph - And more...

Development

Adding New MCP Servers

1. Find a server in the MCP servers repository
2. Add its configuration to gateway/config.json
3. The agent will automatically discover its tools

Customizing the Agent

- Modify the system prompt in src/react_agent/prompts.py
- Update the agent's reasoning in src/react_agent/graph.py
- Add new capabilities by including more MCP servers

Documentation

- LangGraph Documentation
- Model Context Protocol
- MCP Servers Repository

License

This project is licensed under the MIT License - see the LICENSE file for details.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

read_file

write_file

list_directory

search_files

create_entities

create_relations

search_nodes

Claude Desktop / Cursor

Linux

Macos

Windows

LangGraph Coding Agent Team with MCP

Architecture

Getting Started

1. Install Dependencies

Install the gateway package

2. Configure Environment Variables

Supported providers and example models:

- Anthropic: anthropic/claude-3-5-sonnet-20240620

- OpenAI: openai/gpt-4

- OpenRouter: openrouter/openai/gpt-4o-mini

- Google: google/gemini-1.5-pro

API Keys for different providers

OpenRouter Configuration (if using OpenRouter)

3. Configure MCP Servers

4. Start the Gateway Server

5. Configure the Agent

6. Use the Agent

Available Tools

Filesystem Tools

Memory Tools

Development

Adding New MCP Servers

Customizing the Agent

Documentation

License

Install

More like this

Sentry

Github

Git

GitLab

Context 7

Playwright

`read_file`

`write_file`

`list_directory`

`search_files`

`create_entities`

`create_relations`

`search_nodes`