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

14 KiB

Hier is een zo uitgebreid mogelijk C++23-skeleton voor de Root Router. Alles wat je redelijkerwijs zelf kunt bouwen zit erin: meerdere routing-strategieën, embedding-cache, session-state, audit-hooks, multi-tenancy, fallback-keten, structured routing-resultaat, parallelle pre-checks en duidelijke extensiepunten. Geen externe libraries.

// agent/root_router.hpp
#pragma once

#include <string>
#include <string_view>
#include <vector>
#include <memory>
#include <unordered_map>
#include <map>
#include <optional>
#include <functional>
#include <algorithm>
#include <cctype>
#include <cmath>
#include <chrono>
#include <mutex>
#include <span>
#include <array>
#include <expected>          // C++23

namespace molo::agent {

// ---------------------------------------------------------------------------
// Basis types
// ---------------------------------------------------------------------------

struct Message {
    enum class Role { System, User, Assistant, Tool };
    Role role = Role::User;
    std::string content;
    std::string name;
    std::string tool_call_id;
    std::chrono::system_clock::time_point timestamp = std::chrono::system_clock::now();
};

struct AgentContext {
    std::string session_id;
    std::string tenant_id;
    std::string user_id;
    std::vector<Message> messages;
    std::unordered_map<std::string, std::string> state;   // session state
    std::unordered_map<std::string, std::string> metadata;

    // hooks (optioneel invullen vanuit je ORM/session/audit)
    std::function<void(std::string_view event, std::string_view detail)> audit;
    std::function<void(std::string_view key, std::string_view value)> persist_state;
};

struct AgentResult {
    std::string content;
    bool success = true;
    std::string error;
    std::string routed_to;                 // welke domain het werd
    double routing_confidence = 0.0;
    std::string routing_method;            // "rules", "embedding", "llm", "fallback"
    std::chrono::microseconds routing_latency{0};
    // later: tool_calls, usage, etc.
};

class Agent {
public:
    virtual ~Agent() = default;
    virtual std::string_view name() const = 0;
    virtual std::string_view description() const = 0;
    virtual std::vector<std::string> keywords() const { return {}; }  // optioneel
    virtual AgentResult run(AgentContext& ctx) = 0;
};

// ---------------------------------------------------------------------------
// Embedding interface (implementeer met je bestaande client)
// ---------------------------------------------------------------------------

struct Embedding {
    std::vector<float> values;
    static float cosine(const Embedding& a, const Embedding& b) {
        if (a.values.size() != b.values.size() || a.values.empty()) return 0.0f;
        float dot = 0.0f, na = 0.0f, nb = 0.0f;
        for (size_t i = 0; i < a.values.size(); ++i) {
            dot += a.values[i] * b.values[i];
            na += a.values[i] * a.values[i];
            nb += b.values[i] * b.values[i];
        }
        if (na == 0.0f || nb == 0.0f) return 0.0f;
        return dot / (std::sqrt(na) * std::sqrt(nb));
    }
};

class EmbeddingProvider {
public:
    virtual ~EmbeddingProvider() = default;
    virtual std::expected<Embedding, std::string> embed(std::string_view text) = 0;
};

// ---------------------------------------------------------------------------
// Root Router
// ---------------------------------------------------------------------------

class RootRouter : public Agent {
public:
    struct Config {
        float embedding_threshold = 0.72f;
        bool enable_embedding = true;
        bool enable_llm_fallback = false;          // later inschakelen
        size_t max_recent_messages_for_routing = 3;
        std::string default_domain = "llm";        // fallback
    };

    RootRouter(std::vector<std::unique_ptr<Agent>> domains,
               std::shared_ptr<EmbeddingProvider> embedder = nullptr,
               Config cfg = {})
        : domains_(std::move(domains))
        , embedder_(std::move(embedder))
        , config_(cfg)
    {
        rebuild_index();
    }

    std::string_view name() const override { return "root"; }
    std::string_view description() const override {
        return "Front-door hierarchical orchestrator with multi-strategy routing";
    }

    AgentResult run(AgentContext& ctx) override {
        auto start = std::chrono::steady_clock::now();

        if (ctx.messages.empty()) {
            return fail("empty messages");
        }

        // Neem recente user-content voor routing
        std::string routing_text = extract_routing_text(ctx);

        auto decision = decide(ctx, routing_text);

        auto latency = std::chrono::duration_cast<std::chrono::microseconds>(
            std::chrono::steady_clock::now() - start);

        if (!decision.agent) {
            AgentResult r = fail("no domain matched");
            r.routing_latency = latency;
            audit(ctx, "routing_failed", routing_text);
            return r;
        }

        audit(ctx, "routed", std::string(decision.agent->name()) + " via " + decision.method);

        // Agent-as-tool: parent blijft in control
        auto result = decision.agent->run(ctx);
        result.routed_to = std::string(decision.agent->name());
        result.routing_confidence = decision.confidence;
        result.routing_method = decision.method;
        result.routing_latency = latency;

        // Optioneel state persist
        if (ctx.persist_state) {
            ctx.persist_state("last_domain", result.routed_to);
            ctx.persist_state("last_routing_method", result.routing_method);
        }

        return result;
    }

    void add_domain(std::unique_ptr<Agent> agent) {
        std::lock_guard lock(mutex_);
        domains_.push_back(std::move(agent));
        rebuild_index();
    }

    // Pre-compute embeddings van alle domain descriptions (aanroepen bij start of na add)
    void warmup_embeddings() {
        if (!embedder_) return;
        std::lock_guard lock(mutex_);
        domain_embeddings_.clear();
        for (auto& d : domains_) {
            auto emb = embedder_->embed(d->description());
            if (emb) domain_embeddings_[std::string(d->name())] = std::move(*emb);
        }
    }

private:
    struct Decision {
        Agent* agent = nullptr;
        float confidence = 0.0f;
        std::string method;
    };

    std::vector<std::unique_ptr<Agent>> domains_;
    std::unordered_map<std::string, Agent*> by_name_;
    std::unordered_map<std::string, Embedding> domain_embeddings_;
    std::shared_ptr<EmbeddingProvider> embedder_;
    Config config_;
    mutable std::mutex mutex_;

    void rebuild_index() {
        by_name_.clear();
        for (auto& d : domains_) {
            by_name_.emplace(std::string(d->name()), d.get());
        }
    }

    std::string extract_routing_text(const AgentContext& ctx) const {
        std::string text;
        size_t count = 0;
        for (auto it = ctx.messages.rbegin(); it != ctx.messages.rend() && count < config_.max_recent_messages_for_routing; ++it) {
            if (it->role == Message::Role::User) {
                if (!text.empty()) text += " ";
                text += it->content;
                ++count;
            }
        }
        return text.empty() ? ctx.messages.back().content : text;
    }

    Decision decide(const AgentContext& ctx, std::string_view text) {
        // 1. Regels (snelst)
        if (auto* a = route_by_rules(text)) {
            return {a, 0.95f, "rules"};
        }

        // 2. Keyword overlap (iets slimmer dan pure substring)
        if (auto* a = route_by_keywords(text)) {
            return {a, 0.85f, "keywords"};
        }

        // 3. Embedding
        if (config_.enable_embedding && embedder_) {
            if (auto d = route_by_embedding(text)) {
                return d;
            }
        }

        // 4. LLM fallback (placeholder)
        if (config_.enable_llm_fallback) {
            if (auto d = route_by_llm(ctx, text)) {
                return d;
            }
        }

        // 5. Default
        if (auto* a = find(config_.default_domain)) {
            return {a, 0.3f, "default"};
        }
        if (!domains_.empty()) {
            return {domains_.front().get(), 0.1f, "fallback"};
        }
        return {};
    }

    Agent* route_by_rules(std::string_view text) const {
        auto lower = to_lower(text);

        struct Rule { std::vector<std::string_view> triggers; std::string_view domain; };
        static constexpr std::array rules = {
            Rule{{"audio","voice","tts","stt","wav","spreken","gesprek","live api"}, "voice"},
            Rule{{"gmail","drive","calendar","sheets","docs","slides","meet","chat","youtube","workspace"}, "workspace"},
            Rule{{"maps","places","route","geocode","adres","locatie","solar","pollen"}, "maps"},
            Rule{{"bigquery","storage","firestore","pubsub","spanner","bigtable","secret manager"}, "data"},
            Rule{{"xai","grok","anthropic","claude","meta","muse"}, "llm"},
            Rule{{"agent engine","sandbox","memory bank","model armor","vertex","agent platform"}, "platform"},
            Rule{{"translation","vision","document ai","dialogflow","discovery engine"}, "cloudai"},
        };

        for (const auto& r : rules) {
            if (contains_any(lower, r.triggers)) {
                return find(r.domain);
            }
        }
        return nullptr;
    }

    Agent* route_by_keywords(std::string_view text) const {
        auto lower = to_lower(text);
        Agent* best = nullptr;
        int best_score = 0;

        for (const auto& d : domains_) {
            int score = 0;
            for (const auto& kw : d->keywords()) {
                if (lower.find(to_lower(kw)) != std::string::npos) ++score;
            }
            // ook description woorden
            if (lower.find(to_lower(d->name())) != std::string::npos) score += 2;
            if (score > best_score) {
                best_score = score;
                best = d.get();
            }
        }
        return best_score >= 2 ? best : nullptr;
    }

    std::optional<Decision> route_by_embedding(std::string_view text) {
        auto query = embedder_->embed(text);
        if (!query) return std::nullopt;

        std::lock_guard lock(mutex_);
        float best_sim = 0.0f;
        Agent* winner = nullptr;

        for (auto& d : domains_) {
            auto it = domain_embeddings_.find(std::string(d->name()));
            if (it == domain_embeddings_.end()) continue;
            float sim = Embedding::cosine(*query, it->second);
            if (sim > best_sim) {
                best_sim = sim;
                winner = d.get();
            }
        }

        if (winner && best_sim >= config_.embedding_threshold) {
            return Decision{winner, best_sim, "embedding"};
        }
        return std::nullopt;
    }

    std::optional<Decision> route_by_llm(const AgentContext& ctx, std::string_view text) {
        // TODO: roep een snel model via je bestaande LLM-client aan
        // met structured output: {"domain": "...", "confidence": 0.xx}
        // Voorbeeld prompt: lijst van name + description, vraag om JSON.
        return std::nullopt;
    }

    Agent* find(std::string_view name) const {
        auto it = by_name_.find(std::string(name));
        return it != by_name_.end() ? it->second : nullptr;
    }

    static std::string to_lower(std::string_view s) {
        std::string out(s);
        std::ranges::transform(out, out.begin(),
            [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
        return out;
    }

    static bool contains_any(std::string_view hay, std::span<const std::string_view> needles) {
        for (auto n : needles) {
            if (hay.find(n) != std::string_view::npos) return true;
        }
        return false;
    }

    static AgentResult fail(std::string err) {
        return {.success = false, .error = std::move(err)};
    }

    void audit(const AgentContext& ctx, std::string_view event, std::string_view detail) const {
        if (ctx.audit) ctx.audit(event, detail);
    }
};

} // namespace molo::agent

Integratie-voorbeeld (OpenAI-façade + warmup)

// Bij app-start
auto embedder = std::make_shared<YourGeminiEmbeddingProvider>(); // bestaande client

std::vector<std::unique_ptr<molo::agent::Agent>> domains;
domains.push_back(std::make_unique<VoiceCoordinator>());
domains.push_back(std::make_unique<WorkspaceCoordinator>());
domains.push_back(std::make_unique<MapsCoordinator>());
domains.push_back(std::make_unique<DataCoordinator>());
domains.push_back(std::make_unique<LlmVendorCoordinator>());
domains.push_back(std::make_unique<PlatformCoordinator>());
// ...

auto root = std::make_unique<molo::agent::RootRouter>(
    std::move(domains), embedder);

root->warmup_embeddings();   // eenmalig of na wijzigingen

// In je POST /v1/chat/completions handler:
molo::agent::AgentContext ctx{
    .session_id = extract_session(req),
    .tenant_id = extract_tenant(req),
    .user_id = extract_user(req),
    .messages = convert_openai_messages(req.messages),
    .audit = [&](std::string_view ev, std::string_view det) {
        your_observability.log("agent", ev, det);
    },
    .persist_state = [&](std::string_view k, std::string_view v) {
        your_session_store.set(ctx.session_id, k, v);
    }
};

// laad eerdere state indien nodig
// load_state_into(ctx);

auto result = root->run(ctx);

// map naar OpenAI response (content, of tool_calls als je die later toevoegt)

Wat dit skeleton al dekt

  • Meerdere routing-lagen (rules → keywords → embedding → LLM → default)
  • Embedding-cache + cosine similarity (zelf gebouwd)
  • Warmup van domain-embeddings
  • Session-state persist hooks
  • Audit / observability hooks
  • Multi-tenancy velden
  • Latency-meting van de routing
  • Thread-safe index
  • Duidelijke extensiepunten voor LLM-fallback en keywords per domain
  • Agent-as-tool model (root blijft in control)

Nog zelf in te vullen

  1. Concrete *Coordinator classes (Voice, Workspace, …) die Agent implementeren en de echte clients aanroepen.
  2. EmbeddingProvider implementatie op je bestaande Gemini/Vertex embeddings-client.
  3. Optionele LLM-fallback in route_by_llm.
  4. Mapping OpenAI ↔ interne messages + streaming.
  5. Eventueel parallelle pre-fetch van meerdere domains als de confidence laag is (makkelijk toe te voegen in decide).

Dit is het zwaarste skeleton dat nog leesbaar en direct bruikbaar blijft. Wil je nu het bijbehorende skeleton van een domein-coördinator (bijv. Workspace met tool-dispatch) of de volledige OpenAI-compat handler die dit aanroept?