6.0 KiB
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/completionsPOST /v1/chat/completionsmetstream: true(SSE)- Optioneel:
/v1/models,/v1/embeddings(doorzetten of zelf)
De façade:
- Parseert de OpenAI payload.
- Haalt of maakt een session (je hebt al sessions + ORM).
- Geeft de messages + tools (indien aanwezig) door aan de Root Router.
- 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:
-
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. -
Embedding-gebaseerde routing (aanbevolen hybride)
- Gebruik de embeddings-client die je al hebt (Gemini/Vertex of andere).
- Sla embeddings van de
descriptionvan 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.
-
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
- OpenAI-compat endpoint + session-mapping.
- Eenvoudige Root Router (regels + embedding).
- 2–3 domein-coördinatoren (bijv. LLM Vendors, Workspace, Voice) met hun tools.
- Agent-as-tool aanroep + response normalisatie.
- Streaming.
- 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?