client.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/mcp/types.h>
#include <neograph/tool.h>
 
#include <asio/awaitable.hpp>
 
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace neograph::graph { class CancelToken; }
 
namespace neograph::mcp {
 
namespace detail {
class ProtocolSession;
}
 
class NEOGRAPH_API MCPTool : public AsyncTool, public ContextualAsyncTool {
  public:
    MCPTool(const std::string& server_url,
            const std::string& name,
            const std::string& description,
            const json& input_schema);
 
    const ToolDefinition& get_mcp_definition() const noexcept { return definition_; }
 
    CallToolResult execute_result(const json& arguments);
    asio::awaitable<CallToolResult> execute_result_async(const json& arguments);
    asio::awaitable<CallToolResult> execute_result_async(const json& arguments,
                                                         ToolExecutionContext context);
 
    ChatTool get_definition() const override;
 
    asio::awaitable<std::string> execute_async(const json& arguments) override;
 
    asio::awaitable<std::string> execute_async(const json& arguments,
                                               ToolExecutionContext context) override;
 
    std::string get_name() const override { return definition_.name; }
 
  private:
    friend class MCPClient;
    MCPTool(std::shared_ptr<detail::ProtocolSession> session,
            ToolDefinition definition);
    std::shared_ptr<detail::ProtocolSession> protocol_session();
 
    std::string server_url_; 
    std::shared_ptr<detail::ProtocolSession> session_;
    ToolDefinition definition_;
};
 
class NEOGRAPH_API MCPClient {
  public:
    explicit MCPClient(const std::string& server_url);
    MCPClient(const std::string& server_url, MCPClientConfig config);
 
    explicit MCPClient(std::vector<std::string> argv);
    explicit MCPClient(StdioClientConfig config);
 
    MCPClient(const MCPClient&) = delete;
    MCPClient& operator=(const MCPClient&) = delete;
    MCPClient(MCPClient&&) = delete;
    MCPClient& operator=(MCPClient&&) = delete;
 
 
    void shutdown() noexcept;
    bool initialize(const std::string& client_name = "neograph");
 
    asio::awaitable<bool> initialize_async(const std::string& client_name = "neograph");
 
    bool initialize(const std::string& client_name,
                    std::chrono::steady_clock::time_point deadline,
                    std::shared_ptr<graph::CancelToken> cancel_token);
    asio::awaitable<bool> initialize_async(const std::string& client_name,
                                           std::chrono::steady_clock::time_point deadline,
                                           std::shared_ptr<graph::CancelToken> cancel_token);
 
    void set_tool_list_changed_handler(std::function<void()> handler);
 
    bool is_initialized() const noexcept;
    InitializeResult get_initialize_result() const;
 
    std::vector<std::unique_ptr<Tool>> get_tools();
 
    ListToolsPage list_tools(
        const std::optional<std::string>& cursor = std::nullopt);
    asio::awaitable<ListToolsPage> list_tools_async(
        const std::optional<std::string>& cursor = std::nullopt);
 
    std::vector<ToolDefinition> get_tool_definitions();
 
    json call_tool(const std::string& name, const json& arguments);
 
    CallToolResult call_tool_result(const std::string& name,
                                    const json& arguments);
 
    asio::awaitable<json> call_tool_async(const std::string& name,
                                          const json& arguments);
    asio::awaitable<CallToolResult> call_tool_result_async(
        const std::string& name,
        const json& arguments);
    asio::awaitable<CallToolResult> call_tool_result_async(
        const std::string& name,
        const json& arguments,
        std::chrono::steady_clock::time_point deadline,
        std::shared_ptr<graph::CancelToken> cancel_token);
 
    asio::awaitable<json> rpc_call_async(
        const std::string& method,
        const json& params = json::object(),
        std::chrono::steady_clock::time_point deadline =
            std::chrono::steady_clock::time_point::max(),
        std::shared_ptr<graph::CancelToken> cancel_token = {});
 
  private:
    std::shared_ptr<detail::ProtocolSession> session_;
};
 
} // namespace neograph::mcp