M
MCP Directory CURATED DIRECTORY
911 MCP servers indexed
中文
← Back to directory
L

LangGraph.js AI Agent Template

Community
Framework / SDK
Production-ready Next.js + LangGraph.js template with dynamic MCP tool loading and human-in-the-loop approval

This is a framework for building MCP servers or agents, not a server you connect a client to.

How to install ↓ Compare GitHub source repository ↗
Category
Other
Stars
★ 134 Popular
Runtime
Node.js 18+ · Docker
Credentials
Optional API key
License
MIT
Last commit
51FMRS · D

This repository is a full-featured LangGraph.js + Next.js agent template whose value is acting as an MCP client host that dynamically connects to external tool servers, rather than being an MCP server that can itself be added to a client. No server manifest or self-exposed tool list is provided in the README, so tools and transport fields are left empty; this assessment is based solely on the public documentation and described functionality.

Strongest · Documentation 14/20 Weakest · Reliability 5/20

Reliability
5/20
Security and permissions
12/20
Maintenance
11/20
Documentation
14/20
Setup experience
9/20
Why each score
Reliability 5/20
This repository is fundamentally a Next.js full-stack agent host/client template that connects to externally configured MCP servers (stdio/HTTP) chosen by the end user in its UI — it does not itself expose an MCP tool manifest, so there is no initialize/tool-list handshake of its own to verify, and the server manifest is marked 'not cached'. The README describes a plausible happy path (docker compose, Prisma migrations, pnpm dev), but no CI workflow files or test scripts are evidenced (package.json scripts only list lint/format, no test command). Per the static calibration rule, without committed tests/CI the score cannot exceed 12, and the absence of any actual MCP surface to validate pushes it further down.
Security and permissions 12/20
Sensitive credentials (OpenAI/Google/Anthropic API keys, DATABASE_URL) are handled via .env.local rather than hardcoded, and no real secrets appear in examples. The project implements a human-in-the-loop tool-approval flow (allow/deny/modify) that gates dangerous tool execution, and documents OAuth 2.0 for HTTP MCP auth — both positive signals. However, an 'optional auto-approval mode for trusted environments' can bypass confirmation if misconfigured, and the client lets users freely configure arbitrary stdio commands (e.g., filesystem server paths) and HTTP endpoints, with scoping/least-privilege left entirely to the end user with no default sandboxing described. No red-line violation is evident, but confirmation and permission-scoping are incomplete.
Maintenance 11/20
The repo is not archived, carries an MIT license, and shows healthy signals (126 stars, only 1 open issue). However, the README shows no release history, changelog, contributor base, or security-response channel; the author repeatedly inserts personal consulting/LinkedIn promotion into the docs, suggesting likely single-maintainer ownership with unclear governance or versioning path.
Documentation 14/20
The README is fairly thorough — quick start, environment variable setup, an architecture diagram, MCP server configuration examples, and the tool-approval workflow — and links out to layered docs (ARCHITECTURE.md, API.md, OBSERVABILITY.md, OAUTH.md) plus a Zod-generated OpenAPI 3.1 explorer, indicating good documentation structure. But only the README body was available for this review; the linked deep-dive docs' actual content is unverified, and tool-level parameter details, rate limits, cost, and troubleshooting are not spelled out in the provided text, leaving hidden assumptions.
Setup experience 9/20
Setup is documented but multi-step: clone, pnpm install, copy/edit .env.local (requires one of three provider API keys), docker compose for PostgreSQL and MinIO, Prisma generate/migrate, then start the dev server — a typical manual-but-workable path rather than a few-step plug-and-play install. With no CI or test evidence confirming these steps work end-to-end, the static calibration cap applies; additionally, this project is not itself an MCP server a standard MCP client could connect to, and no MCP-client connection config example for this repo is provided.

Static review · not runListed 2026-08-26

Read the FMRS scoring method →

Fit and risk

Best for

  • Teams comfortable with TypeScript/Next.js who want to build their own agent product on top of this scaffold
  • Developers evaluating or demoing MCP dynamic tool loading and human-in-the-loop approval patterns
  • Deployments with existing PostgreSQL/Docker infrastructure willing to self-host a full stack app

Not for

  • Users who just want to plug a single 'tool server' into Claude Desktop or another MCP client — this project is not that kind of drop-in MCP server
  • Users unwilling to operate a database, object storage, and a full front/back-end stack themselves
  • Use cases requiring official LangChain- or MCP-protocol-team maintenance and support guarantees

Required permissions

  • Database read/write access (PostgreSQL) for conversation history and stored MCP server configs
  • Object storage read/write access (S3-compatible storage / MinIO) for file uploads
  • Outbound network access to call OpenAI/Google/Anthropic model APIs
  • Ability to execute local commands or reach remote HTTP endpoints as configured by the user when they register stdio/HTTP MCP servers

Risks and side effects

  • Users can register arbitrary stdio commands as MCP servers via the settings UI; trusting an unverified command can lead to local command execution
  • An optional 'auto-approval' mode skips the human-in-the-loop review of tool calls, amplifying the impact of mistaken or malicious tool invocations
  • API keys and database connection strings are stored as environment variables and must be protected (`.env.local`)
  • The app exposes an OpenAPI explorer at `/api-docs`, so production access controls should be reviewed

Setup

Before you start

Runtime：Node.js 18+ · Docker

DATABASE_URL requiredsecret PostgreSQL connection string; the docker compose stack uses localhost:5434. Required.
OPENAI_API_KEY optionalsecret OpenAI API key for GPT models; one of the three provider keys is enough to run.
GOOGLE_API_KEY optionalsecret Google AI API key for Gemini models; one of the three provider keys is enough to run.
ANTHROPIC_API_KEY optionalsecret Anthropic API key for Claude models; one of the three provider keys is enough to run.
Other optional settings (2)
DEFAULT_MODEL optional Optional default model, e.g. gpt-4o-mini, gemini-1.5-flash, or claude-sonnet-4-5.
LANGFUSE_ENABLED optional Optional toggle to enable Langfuse LLM observability tracing; zero overhead when disabled.
  1. git clone the repository and run pnpm install.
  2. Copy .env.example to .env.local and set DATABASE_URL plus at least one model provider API key (OpenAI/Google/Anthropic).
  3. Run docker compose up -d to start PostgreSQL and MinIO.
  4. Run pnpm prisma:generate and pnpm prisma:migrate to set up the database.
  5. Run pnpm dev and open http://localhost:3000.
  6. To connect external tools, use 'Add MCP Server' in the settings UI to configure a stdio command or an HTTP MCP server URL.

Check that it works

Run docker compose up -d to start PostgreSQL and MinIO, run pnpm prisma:migrate, and open http://localhost:3000; then add a filesystem MCP server via Settings > Add MCP Server and confirm its tools appear in the agent's tool list.

Troubleshooting

  1. Verify `DATABASE_URL` and the chosen model provider's API key are set correctly in `.env.local`
  2. Confirm `docker compose up -d` was run and the PostgreSQL/MinIO containers are healthy
  3. For database errors, check that `pnpm prisma:generate` and `pnpm prisma:migrate` have been run
  4. If using Langfuse observability, verify `LANGFUSE_ENABLED` and related env vars per docs/OBSERVABILITY.md
  5. If adding an MCP server fails, double-check the stdio command/args or the HTTP MCP server URL and auth headers

Things to try

Once connected, you can ask your AI assistant things like:

  • Add a filesystem MCP server in Settings, then list the files in the allowed directory
  • Approve this tool call but modify the path parameter to the Desktop folder
  • Summarize the PDF I uploaded in our last conversation thread
  • Start a new chat thread using the Claude model with auto-approval enabled

Use cases

Standing up a full-featured LangGraph.js AI agent with a chat UI quickly
Dynamically wiring multiple third-party MCP tool servers into an agent without code changes
Automation workflows that require human approval before executing risky tool calls
Chat applications needing persistent multi-turn memory and file/image uploads

Overview

This is an open-source Next.js full-stack template (agentailor/fullstack-langgraph-nextjs-agent) for building AI agents on LangGraph.js. It is not itself an MCP server exposing tools — it is an MCP client/host application: users can add stdio or HTTP MCP servers (e.g. the official filesystem server) through its settings UI, and the app loads, prefixes, and invokes those external tools on the agent's behalf. It also provides human-in-the-loop tool call approval, PostgreSQL-backed persistent conversation memory, S3/MinIO multimodal file uploads, real-time SSE streaming, and optional Langfuse observability. Built with TypeScript, React 19, Next.js, Prisma, and Tailwind CSS, licensed under MIT, and maintained by an individual developer (agentailor/IBJunior) — not an official LangChain or MCP protocol project.

Similar servers

Telegram MCP Server 70 · B

Telegram MCP server powered by Telethon to let MCP clients read chats, manage groups, and send/modify messages, media, contacts, and settings.

★ 1.8k · Tools 76 Compare with this →
Compare with other MCP servers

Source revision 40414f81fb8d Data synced 2026-10-19 Read the FMRS scoring method