AI Automation Workflow Platform

A platform for building and running AI agents visually, as node graphs on a canvas, built from scratch (no LangChain/LangGraph dependency). An agent node isn't just an API call to an LLM — it can call tools, remember past runs (episodic/semantic/procedural memory), retrieve over your own documents (hybrid search + reranking + GraphRAG), and hand off work to other specialized agents (planner/researcher/critic/evaluator) via a supervisor loop. Plain nodes (HTTP, Gmail, Notion, GitHub, shell/Python exec) sit alongside the agent nodes so agents can act on the outside world, not just reason about it. Two working end-to-end demos ship in the Demo Gallery: an inbox-triage pipeline (Gmail -> LLM categorization -> Notion) and a GitHub automation agent team that researches an issue and opens a PR.

Highlights

• Tool-calling agent loop, not just a single prompt/response node
• Episodic, semantic, and procedural memory, with reflection + consolidation
• Retrieval: hybrid (keyword + vector) search, reranking, and GraphRAG
• Multi-agent orchestration: planner/researcher/critic/evaluator roles under a supervisor
• Visual canvas (React Flow) to compose agents and plain nodes into one pipeline, with live run logs and streaming LLM reasoning

Agentic AI skills

Concrete capabilities implemented under backend/app/{ai,memory,retrieval,agents}:

• Agent core: ReAct-style function-calling loop with JSON-schema tool definitions (ai/tools.py, ai/client.py), and constrained decoding to a Pydantic-derived schema for structured output (ai_request node)
• Memory: episodic (memory/episodic.py), semantic via pgvector embeddings/ANN similarity search (ai/embeddings.py), procedural/skill-library memory (memory/procedural.py), plus an LLM-as-judge reflection pass (memory/reflection.py) and periodic summarization-based consolidation (memory/consolidation.py)
• Retrieval: hybrid search — Postgres full-text (ts_rank/tsvector) + dense vector (pgvector) — fused via Reciprocal Rank Fusion (retrieval/fusion.py) and cross-encoder reranking (Cohere rerank-v3.5 via OpenRouter, retrieval/reranking.py) in retrieval/pipeline.py; GraphRAG via entity/relation triple extraction (retrieval/triples.py)
• Multi-agent: planner/researcher/critic/evaluator roles (agents/roles.py) under a supervisor/orchestrator-worker pattern with dynamic routing (agents/supervisor.py)
• Observability: live node events and token-streaming LLM reasoning traces in the frontend LogsPanel.jsx via backend WebSocket run events

Prerequisites

• Python 3.12+ and uv
• Node.js 18+
• Docker (for Postgres + Redis)

Setup

1. Start local infrastructure:

   docker compose up -d

2. Backend:

   cd backend
   uv sync
   cp .env.example .env   # adjust if needed
   uv run python -m app.storage.db   # create tables
   uv run uvicorn app.main:app --reload

3. Frontend (in a separate terminal):

   cd frontend
   npm install
   npm run dev

4. Verify:

   curl localhost:8000/health
   # {"status":"ok"}

   Open the frontend dev server URL (printed by npm run dev, typically http://localhost:5173) to use the visual workflow builder.

Running tests

cd backend
uv run pytest

Project layout

backend/app/
  ai/           # LLM client, embeddings, tool-calling
  memory/       # episodic / semantic / procedural agent memory
  retrieval/    # hybrid search, reranking, GraphRAG
  agents/       # multi-agent roles, supervisor/orchestration loop
  nodes/        # node types: ai_request, http, github, gmail, notion, python/shell exec, ...
  engine/       # workflow execution engine (DAG ordering, executor, retries)
  storage/      # persistence layer (Postgres models, DB session)
  api/          # REST + WebSocket routes, request/response schemas
  core/         # settings, logging, secrets
  main.py       # FastAPI entrypoint
frontend/src/
  components/   # Canvas, NodeLibrary, PropertiesPanel, LogsPanel, DemoGallery, ...
  store/        # Zustand workflow store
  api/          # backend API client
docs/adr/       # architecture decision records
docs/progress/  # build/verification logs

See docs/adr/0001-monorepo-and-stack-choices.md for the reasoning behind the stack and structure.