Files
moloapp/plan2.md
T
2026-10-26 01:31:48 +01:00

6.0 KiB
Raw Blame History

Ja. Hierarchie is de juiste keuze, zeker als alles native in MoloApp moet blijven en je geen externe agent-frameworks wilt.

Met de bestaande HTTP/1.1+HTTP/2 runtime, sessions, ORM, supervisor, observability, multi-tenancy en de Google/LLM-clients die je al hebt, kun je een complete agent-cluster bouwen die naar buiten toe precies één OpenAI Chat Completions endpoint is.

Kernarchitectuur (native C++23)

Client
  ↓
POST /v1/chat/completions   (en streaming)
  ↓
OpenAI-compat façade          ← bestaande HTTP runtime
  ↓
Root Router / Orchestrator    ← snel pad, weinig tools
  ↓
Domein-coördinatoren          ← hiërarchie
  ↓
Specialist agents / tool-executors
  ↓
Bestaande Google-clients + LLM-vendor clients

Alles blijft binnen MoloApp. Geen Python, geen externe agent runtime, geen extra libraries tenzij je ze zelf schrijft.

1. OpenAI-compat façade

Implementeer in de bestaande routing:

  • POST /v1/chat/completions
  • POST /v1/chat/completions met stream: true (SSE)
  • Optioneel: /v1/models, /v1/embeddings (doorzetten of zelf)

De façade:

  1. Parseert de OpenAI payload.
  2. Haalt of maakt een session (je hebt al sessions + ORM).
  3. Geeft de messages + tools (indien aanwezig) door aan de Root Router.
  4. Normaliseert het antwoord terug naar OpenAI-formaat (inclusief tool_calls als je die wilt exposen).

Streaming gaat via de bestaande HTTP/2 of HTTP/1.1 chunked/SSE-ondersteuning die je al hebt.

2. Hiërarchie van agents

Definieer een lichte basis:

struct AgentContext {
  std::string session_id;
  std::vector<Message> messages;
  std::unordered_map<std::string, std::string> state;  // of via ORM
  // multi-tenancy, audit trail, etc.
};

class Agent {
public:
  virtual ~Agent() = default;
  virtual std::string name() const = 0;
  virtual std::string description() const = 0;  // voor routing
  virtual AgentResult run(AgentContext& ctx) = 0;
};

Root Router (één instance, of per-tenant):

  • Ziet alleen de domein-coördinatoren.
  • Doet geen zware tool-calls.
  • Beslist welke coördinator (of combinatie) aan de beurt is.

Domein-coördinatoren (voorbeelden die passen bij jouw lijst):

  • Voice & Live
  • Agent Platform / Runtime / Sessions / Memory / Sandbox
  • Google Cloud AI + Enterprise
  • Data & Ops
  • Maps
  • Workspace
  • LLM Vendors (xAI, Anthropic, Meta/Muse, …)
  • Generic Discovery (de 316 APIs)

Elke coördinator heeft alleen de tools of sub-agents die bij dat domein horen. Dat houdt de keuze-ruimte klein.

Leafs: concrete tool-executors die de bestaande clients aanroepen (service-account, token refresh, Model Armor, etc. zit al in die clients).

3. Routing – efficiënt en zonder externe deps

Drie niveaus, van snel naar zwaarder:

  1. Deterministische / regel-gebaseerde router (snelst)
    Keyword, prefix, of eenvoudige feature-extractie in pure C++.
    Voorbeeld: als de user “calendar”, “gmail”, “drive” zegt → Workspace.
    Als er audio/WAV in zit → Voice.
    Dit kan in microseconden.

  2. Embedding-gebaseerde routing (aanbevolen hybride)

    • Gebruik de embeddings-client die je al hebt (Gemini/Vertex of andere).
    • Sla embeddings van de description van elke coördinator op (in-memory of SQLite via ORM).
    • Bij elke request: embed de laatste user message (of een korte samenvatting), doe cosine similarity, pak de top-1 of top-k.
    • Je kunt een eenvoudige vector store zelf bouwen op SQLite (BLOB + cosine in C++) of zelfs een flat in-memory vector. Geen aparte vector DB nodig.
  3. LLM-router (fallback of voor complexe gevallen)
    Roep een snel model (via je bestaande LLM-clients) met structured output: “kies één van deze domeinen + reden”.
    Alleen gebruiken als 1 en 2 te onzeker zijn.

Je kunt ze combineren: eerst regels, dan embedding, dan pas LLM. Dat houdt de p50-latentie laag.

4. Tool calls en hiërarchie

  • Root Router: bijna geen tools. Alleen routing-beslissing (eventueel als intern tool).
  • Domein-coördinatoren en leafs: wel tool calls.
    Zij mogen de echte Google/LLM-clients aanroepen.
  • Prefer agent-as-tool (synchroon of async): de parent roept de child aan, krijgt resultaat terug en formuleert zelf het finale antwoord. Zo blijft de “één agent”-illusie intact.
  • Handoff alleen voor langlopende stateful flows (bijv. live voice session of multi-turn Workspace wizard). In dat geval houd je de session-state bij en normaliseer je de output weer naar OpenAI-formaat.

Parallelle tool-executie kun je in de coördinator doen met de bestaande async/HTTP-client mogelijkheden of met een eenvoudige thread-pool / coroutine-achtige constructie die je al in de runtime hebt.

5. State, memory, sessions

  • Gebruik de bestaande sessions + ORM.
  • Optioneel: een eigen Memory Bank-achtige tabel (session_id, key, value, embedding, timestamp) die je zelf vult.
  • Audit en governance die je al hebt, kun je direct op agent-stappen hangen (wie routeerde naar wat, welke tool, welke kosten).

6. Supervisor en schaalbaarheid

De bestaande supervisor kan de agent-processen of worker-threads bewaken.
Voor multi-tenancy: de Root Router is tenant-aware (via de session of een header).
Observability: log elke routing-beslissing en tool-call met de bestaande observability-laag.

Concrete startvolgorde

  1. OpenAI-compat endpoint + session-mapping.
  2. Eenvoudige Root Router (regels + embedding).
  3. 2–3 domein-coördinatoren (bijv. LLM Vendors, Workspace, Voice) met hun tools.
  4. Agent-as-tool aanroep + response normalisatie.
  5. Streaming.
  6. Rest van de domeinen + Memory Bank + parallelle calls.

Alles blijft native C++23, gebruikt alleen wat je al hebt (wolfSSL, sqlite, libpq, je eigen Google/LLM-clients), en je bouwt de agent-runtime, routing, eventuele simpele vector store en tool-dispatch zelf.

Wil je dat ik een concreet C++23 skeleton geef voor de Root Router + één domein-coördinator + de OpenAI-façade (inclusief hoe je de bestaande clients eraan hangt)? Of eerst de routing-logica (regels + embedding) uitwerken?