138 lines
6.0 KiB
Markdown
138 lines
6.0 KiB
Markdown
**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:
|
||
|
||
```cpp
|
||
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?
|