AI Chatbot Skills Engine - Backend + Frontend (Python/FastAPI + React)

PROJECT OVERVIEW

We are building a Skills module for an existing AI chatbot SaaS platform. A "Skill" is an automated workflow that the chatbot can trigger during a conversation — for example, looking up an order status via API, sending a notification email, or collecting and submitting form data.

We need a developer to build this module as a standalone, isolated deliverable that we will integrate into our existing platform ourselves.

CORE REQUIREMENTS

1. Skill Execution Engine (Backend)

Build a DAG-based (directed acyclic graph) workflow engine that executes multi-step skills:

Skill structure: A skill is a graph of actions (nodes) connected by edges (transitions). Each action has a type, configuration, and optional conditions for branching.

Action types to support:
- API Call — Make HTTP requests (GET/POST/PUT/DELETE) with configurable URL, headers, body, query params. Support variable interpolation from conversation context or previous action outputs.
- AI Generate — Call an LLM (OpenAI API) with a prompt template to generate/transform text. The prompt may reference variables.
- Data Transform — Apply JSONPath expressions, map/filter data, restructure JSON payloads between actions.
- Knowledge Lookup — Query a vector database (Pinecone) with a search query to retrieve relevant documents.
- Send Email — Send an email via SMTP or API (e.g., SendGrid) with template variables.
- Webhook / Notify — Send a webhook POST to a configurable URL with a JSON payload.
- Human Escalation — Flag the conversation for human handoff, pause skill execution.
- UI Prompt — Present a message or choices to the user and wait for their response before continuing.

Execution flow:
- Topological sort of the DAG to determine execution order.
- Support conditional branching: edges can have conditions (e.g., "if status == 'found', go to action B; otherwise go to action C").
- Actions can reference outputs of previous actions using a variable syntax like {{action_id.output.field}}.
- Skill execution should be resumable (for actions that wait for user input).
- Store execution state per session (which actions ran, their outputs, current position).

Credential vault: Skills that call external APIs need stored credentials. Implement encrypted credential storage (AES-256-GCM) with:
- CRUD operations for credentials (API keys, OAuth tokens).
- OAuth2 authorization code flow support (initiate, callback, token refresh).
- Credentials are scoped per bot/organization.

2. Skill Intent Detection

Before a skill executes, the system needs to detect which skill to trigger based on the user's message:
- Each skill has one or more intent phrases (example utterances).
- Use embedding-based matching: embed intent phrases with OpenAI's text-embedding-3-small, store in a vector index.
- At runtime, embed the user's message and find the closest matching skill above a configurable confidence threshold.
- Return the matched skill (or none if below threshold).

3. AI-Powered Skill Builder (Backend)

Build an AI agent pipeline that can generate complete skill configurations from a natural language description:

User provides a prompt like: "When a customer asks about their order status, call our Shopify API to look up the order by email and return the status."

The system should:
1. Analyze the prompt to determine required actions, API endpoints, data flow.
2. Generate a complete skill structure: actions, edges, configurations.
3. Auto-generate intent phrases for triggering.
4. Return the full skill JSON ready to save.

Use a multi-agent approach:
- An orchestrator LLM decomposes the request and plans the skill structure.
- A builder LLM generates the detailed action configurations.

Support iterative refinement: user can say "add error handling" or "also send a confirmation email" and the system modifies the existing skill.

4. MCP (Model Context Protocol) Integration

Support connecting to external MCP servers that expose tools the chatbot can use:
- Implement an MCP client that communicates via JSON-RPC 2.0 over Streamable HTTP and SSE (Server-Sent Events) transports.
- Discover available tools from an MCP server (tools/list).
- Execute MCP tools (tools/call) as skill actions.
- Store MCP server configurations (URL, auth headers) per bot.

5. Visual Skill Builder (Frontend)

Build a React-based visual editor for creating and editing skills:
- Flow canvas: Use React Flow to render the skill graph. Users drag-and-drop action nodes onto a canvas and connect them with edges.
- Node types: Each action type gets a distinct visual node with an icon, title, and status indicator.
- Configuration panels: Clicking a node opens a side panel with a form to configure that action type (URL fields, header key-value editors, prompt text areas, JSONPath inputs, etc.).
- Edge conditions: Users can click an edge to set branching conditions (simple condition builder with field/operator/value).
- Skill settings panel: Name, description, intent phrases (add/remove), enable/disable toggle, and configuration for trigger conditions.
- Test panel: A panel to simulate skill execution — user provides a test message, system runs the skill and shows step-by-step results (which actions ran, their inputs/outputs, timing).
- Skill templates browser: A gallery of pre-built skill templates users can browse, preview, and instantiate.
- AI generation UI: A dialog/wizard where the user types a natural language description and the system generates the skill, then loads it into the visual editor for review/tweaking.

Frontend tech stack: React (Create React App), plain JavaScript (no TypeScript), plain CSS (no CSS frameworks), React Flow for the graph editor.

6. Skill Templates

Provide a template system:
- Templates are pre-configured skill blueprints (e.g., "Order Status Lookup", "Appointment Booking", "FAQ Escalation").
- Store templates with: name, description, category, required credential types, the full skill graph structure.
- Users can browse templates by category, preview the flow, and create a skill from a template (which copies the structure and lets them customize).

TECH STACK REQUIREMENTS

- Backend language: Python 3.10+
- Backend framework: FastAPI
- Database: PostgreSQL (via asyncpg, raw SQL — no ORM)
- AI/LLM: OpenAI API (GPT-4.1 or later)
- Embeddings: OpenAI text-embedding-3-small
- Vector DB: Pinecone
- Encryption: AES-256-GCM (Python cryptography library)
- Frontend framework: React (Create React App)
- Graph editor: React Flow
- Styling: Plain CSS (no Tailwind, no CSS-in-JS)
- Language: JavaScript (no TypeScript)
- Primary accent color: #5616ea

DELIVERABLES

1. Backend module — A self-contained Python package/directory with:
- All route handlers (FastAPI routers)
- Database models and migration SQL scripts (CREATE TABLE statements)
- Execution engine
- AI generation pipeline
- MCP client
- Intent detection index
- Credential vault logic
- Full API documentation (OpenAPI/Swagger or markdown)

2. Frontend module — A self-contained React component directory with:
- Visual skill builder (React Flow-based)
- All configuration panels
- Test panel
- Template browser
- AI generation wizard
- All required CSS files

3. Integration specification — A document describing:
- All API endpoints (request/response schemas)
- Database schema (tables, columns, types, foreign keys)
- Environment variables / configuration needed
- How the frontend components expect to communicate with the backend (API base URL, auth headers, etc.)

4. Docker demo — A docker-compose setup that runs the backend + a simple frontend demo page, so we can test the module in isolation before integrating.

WHAT WE PROVIDE

- Integration specification: We'll provide a document describing how skills plug into our existing chatbot flow — specifically: the data format of a chat message, how to call back into our system when a skill needs to send a response, and the authentication mechanism your API routes should expect.
- Test API keys: OpenAI API key and Pinecone credentials for development/testing.
- Design reference: Mockups or wireframes for the visual builder UI (if needed).

WHAT WE DO NOT PROVIDE

- Access to our existing codebase. This module must be built as a standalone, isolated deliverable.
- Access to our production infrastructure. You'll develop and test locally.

APPLICATION REQUIREMENTS

In your proposal, please include:
1. Your experience with workflow/automation engines (DAG execution, state machines).
2. Your experience with React Flow or similar graph editor libraries.
3. Your experience with OpenAI API and building AI agent pipelines.
4. A rough architecture outline for how you'd structure the execution engine.
5. Estimated timeline with milestones.
6. Portfolio links or examples of similar work.

Budget: Open to proposals. Please provide a fixed-price quote based on the scope above.

Timeline: Flexible. Show More