Lang-Agent Visual Agent Configuration Platform
A LangGraph-based, finitely programmable agent configuration platform where custom state variables enable more precise node and flow control than traditional Workflows.
Per-dimension scores and reasoning
README only: MCP tools are invoked autonomously by ReactAgent; model and vector-store credentials are configured in the UI; recommending environment variables (PGVECTOR_PASSWORD etc.) is the sole credit. No least-privilege statement, no pre-execution user confirmation, no audit/data-flow logging, no rollback mechanism documented; no lockfile evidence for dependency security; LICENSE appendix copyright holder is blank. Deducted for all of these absences.
README is internally coherent and the Poetry/Yarn install path is complete, but it is a single document with broken example links (e.g., examples/loop_chat. has no target) and failure/error handling is entirely unaddressed. Deducted for broken links and absent failure-message documentation.
Clearly targets users who want visual agent orchestration; scenarios cover chat, RAG, and multi-agent (Supervisor); limitations are honestly stated (custom state variables do not support list types; only OpenAI-compatible channels). However, no Python/Node versions are specified and conditional-expression syntax is only sketchily described. Deducted for missing version matrix and thin trigger-precision detail.
Documentation is well organized (install, configuration, nodes, extension), naming is consistent, install steps are actionable, known limitations are stated, and the Apache-2.0 LICENSE file is complete (full marks). But several example links are empty, there is no CHANGELOG or version number, and no maintainer/contribution guidance or update path. Deducted for broken links, absent versioning, unclear maintenance responsibility.
Custom state variables plus a visual canvas and reusable agents offer clear differentiation from linear-workflow tools; JSON export/import and a chat panel make outputs observable. But the value claim rests on documentation alone with no tests or benchmarks; cost-benefit is left to the user. Deducted for unverified effectiveness claims.
All claims ('limited programmability', node behavior, extension mechanism) come from a single README source with no code, tests, or independent material to corroborate; factual claims and inferred value are mostly not conflated. Deducted for single-source traceability.
- Several example JSON links in the README are empty; claimed example scenarios cannot be verified
- MCP tools are invoked autonomously by the LLM with no documented confirmation, permission scoping, or auditing — isolate deployments accordingly
- Although environment variables are recommended for vector-store credentials, the UI still accepts passwords directly; watch storage and transport security
- No dependency lockfile or language version requirements are provided, so reproducing the install environment is uncertain
- No CHANGELOG or maintainer information; update and security-response path unclear; publisher unverified — assess additionally before production use
What does this agent do, and when should you use it?
Lang-Agent (GitHub: cqzyys/lang-agent) is an open-source (Apache-2.0) visual platform for configuring AI agents on top of LangGraph. The backend is a FastAPI application managed with Poetry; the frontend uses React with HeroUI, ReactFlow and Tailwind CSS, launched via yarn. Unlike traditional Workflow tools that simply pass each node's output as the next node's input, Lang-Agent lets users define custom state variables that nodes and conditional edges read and write, enabling finer control. Users compose agents on a drag-and-drop canvas from nodes (Start, LLM, VLM, Counter, Transformer, document/image loading and saving, code executor, command executor, vector retriever), prebuilt agents (ReactAgent, SupervisorAgent), and edges, then save, run, or import/export JSON. Its design philosophy is closer to comfyUI than to dify or coze: it encourages developers to build nodes tailored to their own business, and custom nodes are added by dropping a XXXNode.tsx file and a XXX_node.py file into designated directories without touching other code.
The platform provides model configuration (currently OpenAI-compatible channels only, with llm, vlm and embedding types), MCP configuration (via langchain-mcp-adapters), and vector store configuration (postgres or milvus, including document management and vectorization). The Agent configuration page shows a resource tree on the left and a canvas on the right: you drag in nodes such as Start, End, Input, LLM, VLM, Counter, Transformer, Doc Loader, Image Loader, Doc Save, code executor, command executor, and vector retriever, plus ReactAgent (which autonomously calls MCP tools) and SupervisorAgent (which orchestrates reusable agents), and connect them with default or conditional edges. State variables (with a default messages variable) are referenced in prompts and conditional-edge expressions via {{messages['x']}} or {{y}} syntax, and nodes update state after execution. Configured agents can be saved to the database, run with results shown in an on-page chatbot, or exported/imported as JSON (the examples folder ships loop_chat., poet1., react_agent_demo., supervisor_demo., and more).
- Python/React developers who want to orchestrate multi-step LLM pipelines visually instead of hand-writing LangGraph code
- Image-understanding scenarios: pipe base64 output from the Image Loader node into a VLM node for prompt-driven recognition or description
- Knowledge retrieval scenarios: vectorize txt/pdf/docx/md documents into postgres or milvus and query them via the vector retriever node
- Tool-calling scenarios: register MCP connections up front and let a ReactAgent autonomously invoke external tools
- Multi-agent orchestration: mark configured agents as reusable and let a SupervisorAgent delegate to them autonomously
- Loop and conditional logic: implement custom loops with the Counter node, Transformer node, and conditional-edge expressions
What are this agent's strengths and limitations?
- Custom state variables can be read/written by nodes and conditional edges, giving more precise control than traditional Workflows that only pass one node's output to the next
- A rich built-in node set out of the box — code executor, command executor, VLM, vector retriever, Counter, Transformer — covers file, multimodal, and retrieval scenarios
- Low-cost extensibility: adding a custom node requires only a XXXNode.tsx on the frontend and a XXX_node.py on the backend, with no changes to other code
- Agents can be exported/imported as JSON, and reusable agents enable composition and cross-environment migration
- Model channels currently support only OpenAI-compatible APIs; broader channel support is still pending
- Only postgres and milvus vector stores are supported, and custom state variables do not yet support list types
- You must deploy two sub-projects yourself (Poetry backend + yarn frontend); no Docker or one-click deployment is documented
- The command executor and Python code executor nodes actually execute local commands and code, so adopters must assess the security boundary themselves
How do you install or deploy this agent?
- Clone: git clone https://github.com/cqzyys/lang-agent.git
- Backend (install Poetry first): cd lang-agent-backend && poetry env use python && poetry shell && poetry install
- Frontend (install yarn first): cd lang-agent-frontend && yarn install
- For vector features, provision a postgres or milvus vector store.
How do you use this agent?
- Start the backend: python -m lang_agent.main
- Start the frontend: yarn dev, then open http://localhost:8820
- In Model Configuration, create a model connection (unique name; type llm/vlm/embedding; OpenAI-compatible ChatOpenAI parameters)
- For tool calls, add an MCP connection using langchain-mcp-adapters parameters; for retrieval, configure a vector store and upload/vectorize documents
- In Agent Configuration, create an agent, drag nodes and agents from the resource tree onto the canvas, set names, prompts and state variables, connect edges, save, and run — results appear in the chatbot at the bottom right.
How does this agent compare with similar options?
The README explicitly contrasts Lang-Agent with dify and coze: its design philosophy is closer to comfyUI, encouraging users to develop nodes tailored to their own business rather than offering a closed, platform-style orchestration experience.