Creating an MCP App with BisenseAI

Prerequisites

• BisenseAI workspace with BisenseFlow and Weaver enabled
• LLM provider API keys in BisenseAI secrets
• Sample inputs representing real MCP scenarios for playground
• Understanding of workflow I/O port binding to Weaver App Nodes
• LangSmith or LangFuse project for production traces
• API gateway or auth layer if exposing public endpoints
• Review of BisenseAI docs/product-document.md for platform terminology

Key Outcomes

• →Production BisenseFlow workflow for MCP core logic
• →Weaver UI bound to workflow inputs/outputs with loading and error states
• →Control-flow guards, retries, and structured JSON errors
• →Interactive playground regression fixtures before deploy
• →REST API deploy with rate limits and rotated keys
• →Optional MCP deploy for MCP tools/resources

Core Challenge

AI clients used to need bespoke integration code per host. MCP standardizes discovery, schemas, and lifecycle for tools and resources.

Your business logic should live once on BisenseFlow and expose to Claude Desktop, IDE agents, and your Weaver app via MCP and REST together.

Mutating actions must be tools; read-only RAG should be resources—mixing them confuses hosts and security reviews.

BisenseAI generates MCP manifests from deployed workflows—no hand-written TypeScript MCP SDK servers for standard patterns.

MCP spec 2025-11-25 unified remote agent tooling under JSON-RPC 2.0 with Streamable HTTP transport, OAuth 2.1 authorization, and standardized tool/resource/prompt manifests, replacing ad-hoc API glue every AI client previously required. BisenseAI deploys BisenseFlow workflows directly as MCP servers with auto-generated schemas, LangSmith trace correlation to JSON-RPC request IDs, and Weaver admin toggles for tool enablement per environment.

What You Will Build

A complete MCP application: Weaver-facing experience wired to BisenseFlow workflows that implement business logic with LLM, Agent, HTTP, Composio, and media nodes as needed.

Graphs are versioned, testable in the playground, and deployed without rewriting orchestration code per release.

Observability tags traces by tenant; optional marketplace packaging lets others fork your template.

Platform Architecture on BisenseAI

BisenseFlow is the source of truth for logic—nodes like LLM, Agent, Vector Store, Text Splitter, HTTP Request, Composio, Playwright, fal.ai, FFmpeg, and custom Python compose visually.

Weaver binds user actions to workflow I/O; real-time execution streams results; time-travel debugging inspects each node output.

Deploy the same workflows as REST APIs or MCP servers so web apps, mobile clients, and Claude Desktop share one runtime.

┌─────────────────┐
│ BisenseFlow     │
│ tool workflows  │──┐
│ resource RAG    │  │
└─────────────────┘  │
         │ Deploy MCP   │
         ▼              │
┌─────────────────┐     │
│ MCP Server      │◀────┘
│ stdio / SSE     │
└────────┬────────┘
         │
    Claude Desktop
    IDE agents
    Weaver (same graphs)

Node Configuration Reference

Designing I/O contracts for MCP

Stable JSON Output fields prevent Weaver regressions. Version breaking changes with new workflow IDs or feature flags.

Document each port in project README; QA uses playground fixtures aligned to schema.

Observability and cost

Tag LangSmith traces with tenant_id, workflow, and action. Use cheap models for routing/enhancement; premium models for final output only.

Alert on error rate and p95 latency per node—bottlenecks often are HTTP tools not LLM.

JSON-RPC 2.0 Message Flow over Streamable HTTP

Clients POST JSON-RPC requests (tools/call, resources/read) to the MCP endpoint with Authorization header. Server streams JSON-RPC response objects as newline-delimited JSON or chunked HTTP body per 2025-11-25 spec. BisenseAI handles transport framing; your BisenseFlow workflow receives deserialized params on Input nodes.

Implement idempotency keys on mutating tools via a Logic node checking request_id cache in Redis or Vector Store metadata to prevent duplicate side effects when clients retry on timeout.

Manifest Generation and Version Pinning

MCP manifests list server name, version, tools[], resources[], prompts[] with inputSchema per entry. Auto-generate from BisenseFlow workflow Input node JSON Schema exports; manual override for descriptions in workflow metadata fields.

Pin manifest version in client configs; breaking inputSchema changes require manifest version bump and client update notification.

Latest Research & Industry Context (2025–2026)

Step-by-Step: Build in BisenseAI

1. 1

   Create mcp-app BisenseFlow workflow

   New workflow `mcp-app-core` on BisenseFlow canvas.

   Add Input nodes; connect to first processing node.

2. 2

   Configure primary LLM/Agent nodes

   Set prompts, temperature, max_tokens in node panels.

   Playground sample input; time-travel outputs.

3. 3

   Add integrations

   Wire HTTP, Composio, fal.ai, FFmpeg, or Playwright as needed.

   Store credentials in BisenseAI secrets.

4. 4

   Control-flow and errors

   Logic branches for validation; retry loops on 429/5xx.

   Structured JSON errors.

5. 5

   JSON Output schema

   Define stable fields for Weaver.

   Document in README.

6. 6

   Weaver UI

   App Nodes + I/O binding + AI-assisted linking.

   Loading/error states.

7. 7

   Streaming (if applicable)

   Enable LLM stream mode; map to UI callback.

   Debounce rapid clicks.

8. 8

   Playground regression

   Save 5–10 fixtures.

   Time-travel diff after changes.

9. 9

   Observability

   LangSmith/LangFuse on.

   Review first 50 traces.

10. 10

    Deploy REST API

    Deploy panel; gateway rate limits.

    Rotate keys.

11. 11

    Optional MCP

    MCP Server deploy; Claude Desktop test.

    Separate tools vs resources.

12. 12

    Production launch

    Complete productionChecklist.

    Monitor 24h error rate.

Common Pitfalls