FrootAI

_{MCP Server (npm)}

From the Roots to the Fruits. It’s simply Frootful.

An open ecosystem where Infra, Platform, and App teams build AI — Frootfully.

A uniFAIng glue for the GenAI ecosystem, enabling deterministic and reliable AI solutions.

The Philosophy Behind FrootAI — The Essence of the FAI Engine

FrootAI is an intelligent way of packaging skills, knowledge, and the essential components of the GenAI ecosystem — all synced, not standalone. Infrastructure, platform, and application layers are woven together so that every piece understands and builds on the others. That’s what “from the roots to the fruits” means: a fully connected ecosystem where Infra, Platform, and App teams build AI — Frootfully.

The FAI Ecosystem

What Makes This Different

Other MCP servers are API wrappers (GitHub MCP wraps the GitHub API, Playwright MCP wraps a browser). FrootAI MCP is a domain knowledge engine with a protocol that binds AI primitives together.

Quick Start

npx frootai-mcp@latest

Other install methods:

npm i -g frootai-mcp                        # Install globally
docker run -i ghcr.io/frootai/frootai-mcp   # Docker (no Node.js needed)
pip install frootai-mcp                      # Python

Connect to Your Agent

VS Code / GitHub Copilot .vscode/mcp.json:

{
  "servers": {
    "frootai": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "frootai-mcp@latest"]
    }
  }
}

{
  "mcpServers": {
    "frootai": {
      "command": "npx",
      "args": ["-y", "frootai-mcp@latest"]
    }
  }
}

{
  "servers": {
    "frootai": {
      "type": "stdio",
      "command": "docker",
      "args": ["run", "-i", "ghcr.io/frootai/frootai-mcp"]
    }
  }
}

MCP Tools (45 total)

Static — bundled knowledge, works offline

• list_modules browse 18 FROOT knowledge modules by layer
• get_module read any module in full (F1–T3)
• lookup_term AI/ML glossary definitions
• search_knowledge full-text search across all modules
• get_architecture_pattern 7 pre-built architecture decision guides
• get_froot_overview complete FROOT framework summary

Live — network-enabled, graceful offline fallback

• fetch_azure_docs search Microsoft Learn for Azure docs
• fetch_external_mcp discover MCP servers from public registries
• list_community_plays browse solution plays from GitHub
• get_github_agentic_os .github Agentic OS 7-primitive guide

Agent Chain — build → review → tune

• agent_build architecture guidance + code patterns, suggests review
• agent_review security, quality, compliance audit, suggests tune
• agent_tune production readiness validation + verdict

Ecosystem — Azure AI intelligence

• get_model_catalog Azure AI model catalog with pricing tiers
• get_azure_pricing monthly cost estimates by scenario + scale
• estimate_cost itemized Azure cost estimate per play + scale
• compare_models side-by-side model comparison for your use case
• compare_plays compare two solution plays (services, cost, complexity)
• semantic_search_plays natural language search across 100 plays
• embedding_playground cosine similarity — educational RAG tool
• run_evaluation quality scoring (groundedness, relevance, coherence, fluency)
• validate_config validate TuneKit configs against best practices
• generate_architecture_diagram Mermaid.js diagram for any play

FAI Engine — the uniFAIng glue (FAI Protocol runtime)

• wire_play resolve FAI Protocol context, bind primitives, activate guardrails
• inspect_wiring audit a play’s wiring — primitives, context, health score
• validate_manifest validate fai-manifest.json schema + completeness
• get_play_detail full play spec — services, config, WAF alignment, evaluation
• list_primitives browse AI primitives by type (agents, skills, hooks…)
• evaluate_quality run quality evaluation with configurable pass/fail thresholds

Scaffold & Create — generate production-ready plays and primitives

• scaffold_play generate a complete play (24+ files) with FAI Protocol auto-wired
• create_primitive create an agent, instruction, or skill with proper frontmatter
• smart_scaffold semantic search → find best matching play → scaffold it

Marketplace — plugin ecosystem (npm for AI primitives)

• marketplace_search semantic search across 77+ plugins by use case
• marketplace_browse paginated listing with 8 category filters
• install_plugin copy plugin primitives into .github/ with conflict detection
• uninstall_plugin remove plugin primitives cleanly
• list_installed scan .github/ and match against marketplace registry
• check_compatibility validate plugin + play alignment + WAF + file conflicts
• validate_plugin check plugin.json schema, naming, and file refs
• compose_plugins multi-install with cross-plugin conflict detection
• publish_plugin validate → generate marketplace entry → register
• check_plugin_updates compare installed vs marketplace versions
• resolve_dependencies topological dependency resolution + install order
• list_external_plugins browse community plugins from external sources
• marketplace_stats full analytics: totals, categories, top plugins, play coverage

Real-World Scenarios — See It In Action

These are real tool calls your AI agent makes when connected to the FrootAI MCP server. Each scenario shows the tool name, what you pass in, and what you get back. Try them in VS Code Copilot Chat, Claude Desktop, or any MCP-compatible client.

You ask → semantic_search_plays("RAG chatbot with Azure AI Search")
You get → Play 01 (Enterprise RAG, 92% match), Play 21 (Agentic RAG, 78%), Play 09 (AI Search Portal, 65%)

You ask → scaffold_play(name: "Invoice Processor", model: "gpt-4o")
You get → 24 files created in solution-plays/101-invoice-processor/ with agents, skills, config,
          infra, evaluation — all auto-wired via FAI Protocol

You ask → wire_play(playId: "01")
You get → Wiring Report: 1 agent → 3 instructions → 3 skills → 3 hooks,
          shared context (4 knowledge modules + 5 WAF pillars), all wired in 43ms

You ask → inspect_wiring(playId: "01")
You get → Visual dependency graph:
          Agents → constrained by → Instructions → invoke → Skills
                → guarded by → Hooks → ALL share → FAI Context

You ask → evaluate_quality(scores: { groundedness: 0.97, relevance: 0.88, safety: 0 })
You get → Pass/fail table per metric against guardrail thresholds.
          Each play has its own quality bar defined in fai-manifest.json.

Step 1: agent_build("Invoice processing API")     → Architecture guidance
Step 2: agent_review("the invoice processing API") → Security + quality audit
Step 3: agent_tune("the invoice processing API")   → Production readiness verdict

You ask → validate_manifest(playId: "01")
You get → ✅ play: valid NN-kebab-case
          ✅ version: valid semver
          ✅ knowledge: 4 modules
          ✅ waf: 5 pillars
          ✅ all paths resolved

You ask → compare_plays(plays: "01,21")
You get → Side-by-side: complexity, services, cost, best-for comparison

Then  → estimate_cost(play: "01", scale: "prod")
You get → Itemized Azure pricing: AI Search $X/mo, OpenAI $Y/mo, App Service $Z/mo

You ask → search_knowledge(query: "how to reduce hallucination in RAG")
You get → Top 5 BM25-ranked sections from knowledge modules, with 500-char previews

Step 1: marketplace_search(query: "security")            → Finds enterprise-security plugin
Step 2: check_compatibility("enterprise-security", "01")  → Verifies WAF alignment
Step 3: install_plugin("enterprise-security", "01")       → Copies primitives, updates manifest

CLI — npx frootai

Note: The CLI has moved to the standalone frootai package (21 commands).

npx frootai help                              # Show all 21 commands
npx frootai info 01                           # Play details + cost estimate
npx frootai list                              # Browse solution plays
npx frootai search "RAG architecture"         # BM25 ranked search
npx frootai scaffold 01                       # Download play + generate templates
npx frootai install 01 --kit devkit           # Install specific kit
npx frootai deploy                            # Guided Azure deployment
npx frootai status                            # Current project context
npx frootai diff                              # Compare local vs GitHub
npx frootai login                             # Check Azure + GitHub auth
npx frootai doctor                            # Health check
npx frootai validate --waf                    # WAF alignment scorecard

Install: npm i -g frootai or use npx frootai@latest

frootai init scaffolds a complete project:

my-ai-project/
 .vscode/mcp.json           MCP auto-connects
 .github/
    copilot-instructions.md
    agents/                Builder, Reviewer, Tuner
    instructions/          Coding standards, patterns
    prompts/               /deploy, /test, /review, /evaluate
 config/                    OpenAI, Search, Guardrails
 evaluation/                Eval thresholds + eval.py
 spec/                      Architecture spec + WAF alignment
 README.md

frootai validate --waf checks your project against the Well-Architected Framework:

• Reliability retry policies, health probes
• Security managed identity, private endpoints
• Cost Optimization right-sized SKUs, token budgets
• Operational Excellence CI/CD, diagnostics
• Performance Efficiency caching, streaming
• Responsible AI content safety, guardrails

HTTP Transport (Remote MCP)

Run as a remote HTTP server alongside stdio — no config change needed:

# Stdio (default — local agents, VS Code, Claude Desktop)
npx frootai-mcp
 
# HTTP server — remote clients, Container Apps, k8s
npx frootai-mcp http
PORT=8080 npx frootai-mcp http
 
# With API key auth
FAI_AUTH_MODE=apikey FAI_API_KEYS=my-secret-key npx frootai-mcp http
 
# Docker
docker run -p 3000:3000 ghcr.io/frootai/frootai-mcp http

Connect a remote client:

{ "servers": { "frootai": { "type": "http", "url": "https://your-host:3000/mcp" } } }

Health probes (Kubernetes / Container Apps):

• GET /healthz — liveness (status, version, uptime, engine)
• GET /readyz — readiness (modules loaded, sessions, cache stats)

Advanced Features

The FAI Protocol — How Wiring Works

The FAI Protocol is what makes FrootAI unique. Every solution play has a fai-manifest.json — a binding contract that declares:

• Context — which knowledge modules and WAF pillars this play uses
• Primitives — which agents, instructions, skills, hooks, and workflows belong to this play
• Guardrails — quality thresholds (groundedness, coherence, relevance, safety, cost)

When you call wire_play("01"), the FAI Engine:

1. Loads the manifest from solution-plays/01-enterprise-rag/spec/fai-manifest.json
2. Resolves all file paths for every primitive
3. Builds shared context — injects knowledge modules + WAF pillars into every primitive
4. Wires agents → instructions → skills → hooks into a connected graph
5. Creates a quality evaluator with the play’s guardrail thresholds

The result: every primitive in the play shares the same knowledge context and quality standards. Change one thing in the manifest, and it propagates everywhere.

{
  "play": "01-enterprise-rag",
  "version": "1.0.0",
  "context": {
    "knowledge": ["R2-RAG-Architecture", "O3-MCP-Tools-Functions", "T3-Production-Patterns"],
    "waf": ["security", "reliability", "cost-optimization"],
    "scope": "enterprise-rag-qa"
  },
  "primitives": {
    "agents": ["./agent.md"],
    "instructions": ["./instructions.md", "../../instructions/python-waf.instructions.md"],
    "skills": ["./.github/skills/deploy-enterprise-rag/"],
    "hooks": ["../../hooks/frootai-secrets-scanner/"],
    "guardrails": {
      "groundedness": 0.95,
      "coherence": 0.90,
      "safety": 0
    }
  }
}

Think of it as docker-compose.yml for AI primitives — one file that defines how everything connects.

Agent FAI REST API

Chat with Agent FAI grounded in FrootAI knowledge: frootai.dev/chatbot 

POST /api/chat POST /api/chat/stream POST /api/search-plays POST /api/estimate-cost GET /api/health

Agent FAI REST API Docs  

What Ships Inside

• FROOT Knowledge Modules — knowledge modules across Foundations, Reasoning, Orchestration, Operations, Transformation
• AI Glossary — AI/ML term definitions
• Solution Plays — pre-tuned deployable solutions with .github Agentic OS
• AI Primitives — agents, instructions, skills, hooks, plugins, workflows
• FAI Engine — FAI Protocol runtime: wire, inspect, validate, evaluate
• FAI Marketplace — 77+ plugins searchable and installable via MCP
• Architecture Decision Guides — RAG, agents, hosting, model selection, cost optimization, determinism
• BM25 Search Engine — pre-built index over 358 documents (plays + knowledge), Robertson IDF ranking
• Progress Tokens — real-time progress for scaffold operations
• Structured Logging — RFC 5424 notifications/message to connected clients
• Tool Annotations — all MCP tools annotated with readOnlyHint/destructiveHint/idempotentHint
• SSE Event Stream — resumable Server-Sent Events in HTTP mode
• Subscribable Resources — live change notifications via fs.watch
• OpenTelemetry — opt-in observability (OTEL_EXPORTER_OTLP_ENDPOINT)

The FrootAI ecosystem is growing. New modules, plays, and tools are added with every release.

Links

2026 FrootAI MIT License

_{AI architecture MCP model-context-protocol Azure RAG agents copilot semantic-kernel infrastructure-as-code solution-plays devkit tunekit agentic-os well-architected open-source frootai}