FrontAgent MCP server
Commit Nov 11, 2026Enables AI clients to perform frontend engineering tasks like code generation, browser automation, and repository management via an agentic interface.
Also known as ceilf6/FrontAgent
- Stars
- 126
- Tools
- 6
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 11, 2026
- License
- MIT
What is FrontAgent MCP?
FrontAgent enables AI clients to perform frontend engineering tasks like code generation, browser automation, and repository management via an agentic interface. It exposes 6 tools, such as frontagent_status, frontagent_run_task, frontagent_plan_task.
Summary generated from the project's README
About FrontAgent MCP server
Building and refactoring modern web applications using React and TypeScript is what FrontAgent facilitates for frontend engineers. It acts as an agentic interface for code generation, browser-aware validation, and repository management. Developers can deploy it as a local stdio MCP server for hosts like Claude Desktop or Cursor, or interact with it through a CLI, VS Code extension, or a standalone desktop application.
The system utilizes a two-stage architecture that separates planning from execution to maintain control through Specification Driven Development. It includes self-healing error recovery and uses repository-aware RAG to minimize path hallucinations. Users connect to LLM providers like OpenAI or Anthropic using API keys and can manage project states with a structured facts memory system.
Beyond writing code, the agent can execute shell commands and manage git or GitHub workflows, such as pushing code and creating pull requests, following user approval. For those seeking to reduce costs, the tool supports distilled Qwen Coder models from Hugging Face to generate execution plans locally without relying on large LLM APIs.
What you can do with it
- 1Refactoring modern web UI codeAn AI client can request the generation or modification of React and Tailwind CSS components.
- 2Validating web pages via browserA developer can ask the agent to inspect a page structure and validate frontend changes.
- 3Automating git and GitHub workflowsThe agent can handle the entire process of committing code and opening pull requests.
- 4Generating plans with local modelsUsers can use distilled models to create frontend execution plans locally to save on API costs.
Written from the project's README. Every use case is checked against a quote from it.
FrontAgent MCP tools 6
Detected from the READMEfrontagent_statusfrontagent_run_taskfrontagent_plan_taskfrontagent_validate_sddfrontagent_list_skillsfrontagent_init_sdd
Configuration
API_KEYBASE_URLFRONTAGENT_FILESENSE_ENABLEDFRONTAGENT_FILESENSE_MAX_BYTESFRONTAGENT_FILESENSE_MAX_ENTRIESFRONTAGENT_FILESENSE_OUTPUTFRONTAGENT_FILESENSE_TIMEOUT_MSFRONTAGENT_FILESENSE_WRITE_MODEFRONTAGENT_OPENVIKING_API_KEYFRONTAGENT_OPENVIKING_CORPUSFRONTAGENT_OPENVIKING_ENDPOINTFRONTAGENT_OPENVIKING_L1_ENTRYFRONTAGENT_OPENVIKING_NAMESPACEFRONTAGENT_OPENVIKING_TIMEOUT_MSFRONTAGENT_RAG_BRANCHFRONTAGENT_RAG_EMBEDDING_API_KEYFRONTAGENT_RAG_EMBEDDING_BASE_URLFRONTAGENT_RAG_EMBEDDING_BATCH_SIZEFRONTAGENT_RAG_EMBEDDING_DIMENSIONSFRONTAGENT_RAG_EMBEDDING_MODELFRONTAGENT_RAG_EMBEDDING_TIMEOUT_MSFRONTAGENT_RAG_KEYWORD_CANDIDATESFRONTAGENT_RAG_KEYWORD_WEIGHTFRONTAGENT_RAG_MAX_RESULTSFRONTAGENT_RAG_QUERY_REWRITE_MAX_TOKENSFRONTAGENT_RAG_QUERY_REWRITE_TEMPERATUREFRONTAGENT_RAG_REPOFRONTAGENT_RAG_RERANKER_API_KEYFRONTAGENT_RAG_RERANKER_BASE_URLFRONTAGENT_RAG_RERANKER_CANDIDATE_COUNTFRONTAGENT_RAG_RERANKER_MAX_DOCUMENT_CHARSFRONTAGENT_RAG_RERANKER_MODELFRONTAGENT_RAG_RERANKER_TIMEOUT_MSFRONTAGENT_RAG_SEMANTIC_CANDIDATESFRONTAGENT_RAG_SEMANTIC_WEIGHTFRONTAGENT_RAG_SOURCEFRONTAGENT_RAG_SYNC_ON_QUERYFRONTAGENT_RAG_VECTOR_STORE_PROVIDERFRONTAGENT_RAG_WEAVIATE_API_KEYFRONTAGENT_RAG_WEAVIATE_BATCH_SIZEFRONTAGENT_RAG_WEAVIATE_COLLECTION_PREFIXFRONTAGENT_RAG_WEAVIATE_TIMEOUT_MSFRONTAGENT_RAG_WEAVIATE_URL
Automated checks
Ran Nov 15, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachableceilf6/frontagent is public and reachablegithub.com/ceilf6/frontagent ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-11github.com/ceilf6/frontagent ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model6 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubFrontAgent
Enterprise-grade frontend AI coding agent and MCP-powered automation system - constrained by Specification Driven Development (SDD) for controlled planning, code generation, browser-aware execution, and repository workflows
中文文档 | Quick Start | Architecture | Design Doc
FrontAgent is an open-source AI coding agent for frontend engineering. It helps teams build, modify, validate, and ship web applications through an agentic CLI, VS Code extension, desktop app, local MCP server, RAG planning, browser-aware automation, and SDD guardrails.
Distilled Planner Models: FrontAgent's Planner stage has been distilled into Hugging Face planner assets collected under FrontAgent: Frontend Engineering Agent. Load the published adapters on their supported Qwen Coder base models to generate frontend execution plans directly, without calling large LLM APIs. The training workflow, prompts, evaluation scripts, and Hugging Face release metadata live in models/frontagent-planner.
Use FrontAgent when you need a frontend AI agent that can:
-
Generate and refactor React, TypeScript, Vite, Tailwind CSS, and modern web UI code from structured execution plans.
-
Run as an AI agent CLI, VS Code AI extension, desktop agent app, or stdio MCP server for Claude Desktop, Cursor, Codex, and other MCP hosts.
-
Combine repository-aware RAG, Filesense navigation, facts memory, and module dependency tracking to reduce path hallucinations.
-
Execute browser-aware validation, page inspection, shell commands, and git/gh repository workflows behind explicit safety controls.
-
Enforce Specification Driven Development (SDD), minimal patches, self-healing error recovery, and quality gates for production frontend teams.
-
Use distilled Qwen Coder planner models from Hugging Face for local or lower-cost frontend execution planning.
-
✅ Two-Stage Architecture - Separate planning and execution to avoid JSON parsing errors and enable dynamic code generation
-
✅ Phase-Based Execution - Steps grouped by phases with error recovery within each phase
-
✅ Self-Healing - Tool Error Feedback Loop automatically analyzes errors and generates fix steps
-
✅ Facts Memory - Structured facts-based context system for precise project state tracking
-
✅ Module Dependency Tracking - Automatic import/export parsing to detect path hallucinations
-
✅ Hallucination Prevention - Multi-layer hallucination detection and interception
-
✅ SDD Constraints - Specification Driven Development as hard constraints for agent behavior
-
✅ MCP Protocol - Controlled tool invocation via Model Context Protocol
-
✅ Minimal Changes - Patch-based code modifications with rollback support
-
✅ Web Awareness - Understand page structure through browser MCP
-
✅ Shell Integration - Terminal command execution (requires user approval)
-
✅ Pre-Planning Scan - Scan project structure before planning to generate accurate file paths
-
✅ Auto Port Detection - Automatically detect dev server ports from config files
-
✅ Remote Hybrid RAG - Full-repository indexing with submodule exclusion, combining BM25 keyword search and embedding-based semantic search
-
✅ Filesense Navigation - Budgeted current-repository navigation with generated schemas and notes
-
✅ LangGraph Engine (Optional) - Switchable graph-based execution engine with optional checkpoints
-
✅ Planner Skills Layer - Reusable planning skills for task decomposition and phase injection
-
✅ Distilled Planner Assets - Repository-native training, evaluation, and release assets for the Hugging Face Planner model collection
-
✅ Skill Lab - Benchmark, improve, and promote content skills with local eval suites
-
✅ VS Code Sidebar - Marketplace extension with task runs, SDD helpers, secure settings, and run logs
-
✅ OSS Harness - Local contract, quality, GitNexus, and workflow gates for maintainer-friendly changes
-
✅ Repository Management Phase - Auto git/gh workflow after acceptance (commit, push, PR)
-
✅ Cross-Session Memory - Four-phase memory system (preload, runtime recall, post-task persistence, structured storage) that persists project facts, error resolutions, and dependency state across runs
Current Release Snapshot
The repository is currently aligned on frontagent@2.2.0 for both the npm CLI package and the VS Code extension.
- Runtime requirements: Node.js
>=20.0.0; VS Code extension engine^1.120.0. - Build output:
pnpm buildbuilds the monorepo, bundles the CLI, syncs the VS Code version, and packagesapps/vscode/frontagent-2.2.0.vsix. - Quality gates:
pnpm quality:predev,pnpm quality:precommit,pnpm quality:ci, andpnpm quality:localcombine contract checks, linting, typechecking, tests, workflow tests, and build verification. - v2.2.0 focus: the Electron desktop client, headless non-interactive CLI mode, session resume, lifecycle hooks, declarative permission rules, context zone budgets, the mcp-web-fetch adapter, and CLI/guard correctness fixes.
Three Ways to Use FrontAgent
FrontAgent supports terminal, VS Code, and standalone desktop workflows:
- CLI: use
fa init,fa run, RAG commands, Skill Lab, and automation-friendly workflows directly from your terminal. - VS Code Extension: use the FrontAgent sidebar task console to run tasks, attach the current file or selection, provide a browser URL, review phase/step progress, approve sensitive actions, initialize/validate SDD, and open run logs from inside VS Code.
- Desktop App: a standalone Electron GUI (
apps/desktop) that reuses the same Node runtime spine — a Task Console for launching tasks, watching live phase/step telemetry, and approving sensitive actions, plus a Settings panel for the LLM provider/model.
Install the VS Code extension from the Marketplace by searching for FrontAgent or the extension id ceilf6.frontagent.
Endpoint trust in the VS Code extension
frontagent.provider, frontagent.model, and frontagent.baseUrl select the host that receives your API key and task context, so the extension treats them as user-scoped configuration. A repository may propose them through its own .vscode/settings.json, but FrontAgent withholds a workspace-supplied endpoint until you confirm that exact provider/model/base URL for that workspace folder, re-asks whenever the repository changes it, and ignores it entirely when the workspace is not trusted. frontagent.apiKey is machine-scoped and is read only from User Settings. See apps/vscode/README.md for details and the reset command.
Desktop App
The desktop client is a sandboxed Electron window wired to the real runtime (window.frontagent → IPC → runFrontAgentTask); it persists settings under your OS user-data directory and degrades gracefully if the runtime is unavailable.
- Download: grab the unsigned per-platform archive
frontagent-desktop-${version}-${os}-${arch}.zipfrom the GitHub Releases page (published automatically for eachv*tag), unzip, and launch thefrontagentexecutable. The LLM API key is read from the environment (PROVIDER_API_KEY/API_KEY); set provider/model/base URL in the in-app Settings panel. - Build locally:
pnpm --filter @frontagent/desktop packageproduces an unpacked app underapps/desktop/release/, andpnpm --filter @frontagent/desktop devruns it against the Vite dev server. Thereleasescript (pnpm --filter @frontagent/desktop run release) produces the distributable zip.
Desktop archives are currently unsigned; code signing, notarization, and native installers (dmg/nsis/AppImage) are planned follow-ups.
CLI Quick Start
# 1. Install globally via npm
npm install -g frontagent
# or using pnpm
pnpm add -g frontagent
# or using yarn
yarn global add frontagent
# 2. Configure LLM (supports OpenAI and Anthropic)
# OpenAI config
export PROVIDER="openai"
export BASE_URL="https://api.openai.com/v1"
export MODEL="gpt-4"
export API_KEY="sk-..."
# Or Anthropic config
export PROVIDER="anthropic"
export BASE_URL="https://api.anthropic.com"
export MODEL="claude-sonnet-4-20250514"
export API_KEY="sk-ant-..."
# 3. Navigate to your project directory and initialize SDD
cd your-project
fa init
# 4. Let AI help you complete tasks
fa run "Create a user login page"
fa run "Optimize homepage loading performance"
fa run "Add dark mode support"
# Use LangGraph engine + checkpoint (optional)
fa run "Add route guards and open a PR" --engine langgraph --langgraph-checkpoint
MCP Server
FrontAgent can run as a local stdio MCP Server for MCP hosts such as Claude Desktop, Cursor, Codex, and other clients that can launch a command-based MCP server.
MCP mode exposes FrontAgent's upper-level agent capabilities only. It does not expose raw internal tools such as read_file, apply_patch, run_command, browser tools, or rag_query directly to the external host.
Start the Server
# Use the installed CLI
fa mcp serve
# Or run from a source checkout after pnpm build
node /absolute/path/to/FrontAgent-app/apps/cli/dist/index.js \
mcp serve
By default, FrontAgent resolves the project root from the MCP host's workspace roots when the host exposes exactly one file root. If host roots are unavailable, it falls back to the MCP server process current working directory.
Use --project-root only when you want to pin the server to a specific project, or when the host exposes multiple workspace roots and FrontAgent cannot choose safely:
fa mcp serve --project-root /absolute/path/to/your-project
One MCP server process is bound to one resolved project root.
Useful server options:
fa mcp serve \
--engine native \
--security-mode balanced \
--rag-repo https://github.com/ceilf6/Lab.git \
--rag-branch main \
--filesense-enabled true \
--log-file .frontagent/runs/mcp-server.log
Host Configuration
Most MCP hosts use the same mcpServers shape. Start with the simple config:
{
"mcpServers": {
"frontagent": {
"command": "fa",
"args": ["mcp", "serve"]
}
}
}
If your host UI has separate fields, use:
- Command:
fa - Args:
mcp,serve
Do not put fa mcp serve into the command field as one string.
If the host reports command "fa" not found or env: node: No such file or directory, the GUI host probably does not inherit your terminal shell PATH. Then use absolute paths:
which node
which fa
{
"mcpServers": {
"frontagent": {
"command": "/opt/homebrew/bin/node",
"args": ["/opt/homebrew/bin/fa", "mcp", "serve"]
}
}
}
If you are using a source checkout instead of a globally linked package, point node at the built CLI file after pnpm build:
{
"mcpServers": {
"frontagent": {
"command": "/opt/homebrew/bin/node",
"args": ["/absolute/path/to/FrontAgent-app/apps/cli/dist/index.js", "mcp", "serve"]
}
}
}
For direct LLM fallback, pass environment variables through the host config:
{
"mcpServers": {
"frontagent": {
"command": "fa",
"args": ["mcp", "serve"],
"env": {
"PROVIDER": "openai",
"BASE_URL": "https://api.openai.com/v1",
"MODEL": "gpt-4",
"API_KEY": "sk-..."
}
}
}
}
Examples of where to put the config:
- Claude Desktop: add the server under
mcpServersinclaude_desktop_config.json. - Cursor: add the server under
mcpServersin your Cursor MCP config, for example.cursor/mcp.json. - Codex or other MCP hosts: use the same command, args, and env values in the host's MCP server configuration surface.
Exposed MCP Tools
FrontAgent exposes six MCP tools:
frontagent_status: returns project root, SDD status, visible skills, LLM backend status, RAG status, and run-log directory.frontagent_run_task: runs a full FrontAgent task. Inputs includetask,type,files,url,sddPath, andsecurityMode.frontagent_plan_task: generates a FrontAgent execution plan without executing tools or writing files.frontagent_validate_sdd: validates the project SDD file.frontagent_list_skills: lists visible content skills.frontagent_init_sdd: creates an SDD template. Existing files are not overwritten unlessforce=true.
frontagent_run_task returns structured JSON text with:
{
"success": true,
"taskId": "task_...",
"output": "...",
"error": null,
"duration": 1234,
"runLogPath": "/absolute/path/.frontagent/runs/...",
"executedStepsSummary": [],
"securityDecisions": []
}
LLM Backend Behavior
MCP mode uses auto LLM backend selection:
- If the host supports MCP Sampling, FrontAgent asks the host model through
sampling/createMessage. - If Sampling is unsupported or unavailable, FrontAgent falls back to direct LLM configuration.
Direct fallback uses the same environment variables and flags as fa run:
export PROVIDER="openai"
export BASE_URL="https://api.openai.com/v1"
export MODEL="gpt-4"
export API_KEY="sk-..."
Read-only tools such as frontagent_status, frontagent_list_skills, frontagent_validate_sdd, and frontagent_init_sdd do not require LLM configuration. frontagent_run_task and frontagent_plan_task require either host Sampling support or a valid direct LLM fallback.
Security Model
MCP mode keeps FrontAgent's internal safety boundary:
- External MCP hosts cannot directly call internal file, shell, browser, or RAG tools.
- Internal file writes, shell commands, browser actions, and other side effects still go through
SecurityManager. - The default security mode is
balanced. - Because stdio MCP does not provide FrontAgent's interactive approval UI, any action that requires an
askdecision fails closed. frontagent_init_sddonly writes SDD files inside the configured project root.
Remote RAG
FrontAgent now supports a full remote repository knowledge base flow for planning and code generation:
- It syncs the remote repository into
.frontagent/rag-cache/repo - It indexes the full repository by chunk, and automatically excludes Git submodule paths
- It runs BM25 keyword retrieval and embedding-based semantic retrieval in parallel
- It applies metadata filters to each candidate list, then fuses the ranked results
- Built indexes and embedding vectors are cached under
.frontagent/rag-cache
Default knowledge source:
- Repository:
https://github.com/ceilf6/Lab.git - Source mode:
gitby default; whenFRONTAGENT_OPENVIKING_ENDPOINTis configured FrontAgent defaults tocomposite(OpenVikingfirst, Git RAG fallback)
CLI options:
fa run "Explain React setState behavior" \
--provider openai \
--base-url https://yunwu.ai/v1 \
--api-key YOUR_TOKEN \
--rag-repo https://github.com/ceilf6/Lab.git \
--rag-branch main \
--rag-keyword-candidates 40 \
--rag-semantic-candidates 40 \
--rag-keyword-weight 0.45 \
--rag-semantic-weight 0.55
# When provider=openai, RAG embeddings inherit the same base-url/api-key by default.
# Override them only if your embedding endpoint is different.
fa run "Explain React setState behavior" \
--provider openai \
--base-url https://yunwu.ai/v1 \
--api-key YOUR_TOKEN \
--rag-embedding-model text-embedding-3-small \
--rag-embedding-batch-size 32 \
--rag-embedding-timeout-ms 30000
# Use Weaviate as the semantic vector store (BM25 stays local)
fa run "Explain React setState behavior" \
--provider openai \
--base-url https://yunwu.ai/v1 \
--api-key YOUR_TOKEN \
--rag-embedding-model text-embedding-3-small \
--rag-vector-store-provider weaviate \
--rag-weaviate-url http://127.0.0.1:8080 \
--rag-weaviate-collection-prefix FrontAgentRagChunk \
--rag-weaviate-batch-size 64 \
--rag-weaviate-timeout-ms 30000
# Use OpenViking Wiki as the primary knowledge provider, with Git RAG fallback
fa run "Where is FrontAgent RAG implemented?" \
--rag-source composite \
--open-viking-endpoint https://openviking.example.com/query \
--open-viking-corpus wiki \
--open-viking-namespace docs/openviking \
--open-viking-l1-entry docs/openviking/frontagent-l1.md
# Require OpenViking only and disable Git fallback
fa run "Where is FrontAgent RAG implemented?" \
--rag-source openviking \
--open-viking-endpoint https://openviking.example.com/query \
--disable-open-viking-fallback
# Disable LLM query rewrite before retrieval
fa run "How to build a custom selector" \
--disable-rag-query-rewrite
# Cross-encoder reranking is enabled by default after BM25 + embedding candidate retrieval
fa run "Explain React setState behavior" \
--provider openai \
--base-url https://yunwu.ai/v1 \
--api-key YOUR_TOKEN \
--rag-embedding-model text-embedding-3-small \
--rag-reranker-model jina-reranker-v2-base-multilingual \
--rag-reranker-base-url https://your-reranker-endpoint/v1 \
--rag-reranker-timeout-ms 30000
# Disable reranking for a run
fa run "Explain React setState behavior" \
--disable-rag-reranker
# Disable semantic retrieval and use BM25 only
fa run "Explain React setState behavior" \
--disable-rag-semantic
# Disable remote RAG for a run
fa run "Create a page" --disable-rag
# Force a remote git sync before this query; by default FrontAgent reuses the local cache
fa run "Explain React setState behavior" --rag-sync-on-query
Skill Lab
FrontAgent now includes a local Skill Lab workflow for iterating on content skills under skills/.
# List visible content skills
fa skill list
# Scaffold a new content skill
fa skill scaffold pricing-audit
# Generate starter trigger evals for a skill
fa skill init-evals frontend-design
# Generate starter behavior evals (binary checks for output quality)
fa skill init-behavior-evals frontend-design
# Benchmark current trigger behavior
fa skill benchmark frontend-design
# Benchmark trigger + behavior together
fa skill benchmark frontend-design --behavior
# Generate a candidate revision and compare it against baseline
fa skill improve frontend-design
# Improve with both trigger and behavior eval suites
fa skill improve frontend-design --behavior
# Promote a candidate after review
fa skill promote frontend-design 20260331T120000Z
The current Skill Lab flow supports two eval tracks for content skills:
- Trigger evals: whether the skill activates correctly.
- Behavior evals: whether the final output quality passes binary checks.
You can run trigger-only (default) or trigger + behavior (--behavior) in benchmark/improve.
Environment variables:
export FRONTAGENT_RAG_SOURCE="composite" # git | openviking | composite
export FRONTAGENT_OPENVIKING_ENDPOINT="https://openviking.example.com/query"
export FRONTAGENT_OPENVIKING_API_KEY=""
export FRONTAGENT_OPENVIKING_CORPUS="wiki"
export FRONTAGENT_OPENVIKING_NAMESPACE="docs/openviking"
export FRONTAGENT_OPENVIKING_L1_ENTRY="docs/openviking/frontagent-l1.md"
export FRONTAGENT_OPENVIKING_TIMEOUT_MS="30000"
export FRONTAGENT_RAG_REPO="https://github.com/ceilf6/Lab.git"
export FRONTAGENT_RAG_BRANCH="main"
export FRONTAGENT_RAG_SYNC_ON_QUERY="false"
export FRONTAGENT_RAG_MAX_RESULTS="5"
export FRONTAGENT_RAG_KEYWORD_CANDIDATES="40"
export FRONTAGENT_RAG_SEMANTIC_CANDIDATES="40"
export FRONTAGENT_RAG_KEYWORD_WEIGHT="0.45"
export FRONTAGENT_RAG_SEMANTIC_WEIGHT="0.55"
export FRONTAGENT_RAG_QUERY_REWRITE_MAX_TOKENS="160"
export FRONTAGENT_RAG_QUERY_REWRITE_TEMPERATURE="0.1"
export FRONTAGENT_RAG_RERANKER_MODEL="jina-reranker-v2-base-multilingual"
export FRONTAGENT_RAG_RERANKER_BASE_URL="https://your-reranker-endpoint/v1"
export FRONTAGENT_RAG_RERANKER_API_KEY="sk-..."
export FRONTAGENT_RAG_RERANKER_CANDIDATE_COUNT="20"
export FRONTAGENT_RAG_RERANKER_MAX_DOCUMENT_CHARS="1800"
export FRONTAGENT_RAG_RERANKER_TIMEOUT_MS="30000"
export FRONTAGENT_RAG_EMBEDDING_MODEL="text-embedding-3-small"
export FRONTAGENT_RAG_EMBEDDING_BASE_URL="https://api.openai.com/v1"
export FRONTAGENT_RAG_EMBEDDING_API_KEY="sk-..."
export FRONTAGENT_RAG_EMBEDDING_DIMENSIONS=""
export FRONTAGENT_RAG_EMBEDDING_BATCH_SIZE="32"
export FRONTAGENT_RAG_EMBEDDING_TIMEOUT_MS="30000"
export FRONTAGENT_RAG_VECTOR_STORE_PROVIDER="weaviate"
export FRONTAGENT_RAG_WEAVIATE_URL="http://127.0.0.1:8080"
export FRONTAGENT_RAG_WEAVIATE_API_KEY=""
export FRONTAGENT_RAG_WEAVIATE_COLLECTION_PREFIX="FrontAgentRagChunk"
export FRONTAGENT_RAG_WEAVIATE_BATCH_SIZE="64"
export FRONTAGENT_RAG_WEAVIATE_TIMEOUT_MS="30000"
FrontAgent MCP questions
What tools does FrontAgent MCP provide?
It exposes 6 tools, including frontagent_status, frontagent_run_task, frontagent_plan_task, frontagent_validate_sdd, frontagent_list_skills.
What can FrontAgent automate in frontend development?
It automates the generation and refactoring of React, TypeScript, Vite, and Tailwind CSS code.
How can I integrate FrontAgent with Claude Desktop or Cursor?
You can run it as a local stdio MCP server using the command fa mcp serve.
Does FrontAgent support local execution planning?
Yes, it provides distilled Qwen Coder planner models from Hugging Face for local or lower-cost planning.