node.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/graph/types.h>
#include <neograph/graph/state.h>
 
#include <asio/awaitable.hpp>
 
#include <stdexcept>
 
namespace neograph::graph {
 
struct RunContext;
 
struct NodeInput {
    const GraphState&  state;
 
    const RunContext&  ctx;
 
    const GraphStreamCallback* stream_cb = nullptr;
};
 
using NodeOutput = NodeResult;
 
#define NEOGRAPH_DEPRECATED_VIRTUAL                                  \
    [[deprecated(                                                    \
        "v0.4: override run(NodeInput) -> awaitable<NodeOutput> "    \
        "instead. The legacy 8-virtual chain is preserved for "      \
        "back-compat through v0.5 and removed in v1.0. "             \
        "Migration recipe: docs/migration-v0.4-to-v1.0.md")]]
 
class NEOGRAPH_API GraphNode {
public:
    virtual ~GraphNode() = default;
 
    virtual asio::awaitable<NodeOutput> run(NodeInput in) = 0;
 
    virtual std::string get_name() const = 0;
};
 
class NEOGRAPH_API LLMCallNode : public GraphNode {
public:
    LLMCallNode(const std::string& name, const NodeContext& ctx);
 
    asio::awaitable<NodeOutput> run(NodeInput in) override;
 
    std::string get_name() const override { return name_; }
 
private:
    std::string              name_;
    std::shared_ptr<Provider> provider_;
    std::vector<Tool*>       tools_;
    std::string              model_;
    std::string              instructions_;
 
    CompletionParams build_params(const GraphState& state) const;
};
 
class NEOGRAPH_API ToolDispatchNode : public GraphNode {
public:
    ToolDispatchNode(const std::string& name, const NodeContext& ctx);
 
    asio::awaitable<NodeOutput> run(NodeInput in) override;
    std::string get_name() const override { return name_; }
 
private:
    std::string        name_;
    std::vector<Tool*> tools_;
};
 
// Forward declaration
class GraphEngine;
 
class NEOGRAPH_API IntentClassifierNode : public GraphNode {
public:
    IntentClassifierNode(const std::string& name, const NodeContext& ctx,
                         const std::string& prompt,
                         std::vector<std::string> valid_routes);
 
    asio::awaitable<NodeOutput> run(NodeInput in) override;
    std::string get_name() const override { return name_; }
 
private:
    std::string               name_;
    std::shared_ptr<Provider>  provider_;
    std::string               model_;
    std::string               prompt_;
    std::vector<std::string>  valid_routes_;
 
    CompletionParams build_params(const GraphState& state) const;
    std::vector<ChannelWrite> route_from(const std::string& intent) const;
};
 
class NEOGRAPH_API SubgraphNode : public GraphNode {
public:
    SubgraphNode(const std::string& name,
                 std::shared_ptr<GraphEngine> subgraph,
                 std::map<std::string, std::string> input_map = {},
                 std::map<std::string, std::string> output_map = {});
 
    asio::awaitable<NodeOutput> run(NodeInput in) override;
    std::string get_name() const override { return name_; }
 
private:
    std::string name_;
    std::shared_ptr<GraphEngine> subgraph_;
    std::map<std::string, std::string> input_map_;
    std::map<std::string, std::string> output_map_;
 
    json build_subgraph_input(const GraphState& state) const;
    std::vector<ChannelWrite> extract_output(const json& subgraph_output) const;
};
 
} // namespace neograph::graph