MRMcp.h

Go to the documentation of this file.

#pragma once
 
#include "exports.h"
 
#include "MRMesh/MRExpected.h"
 
#include <nlohmann/json.hpp>
 
#include <filesystem>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
namespace MR::Mcp
{

namespace Schema
{
    struct Base
    {
      protected:
        nlohmann::json json;
        Base( nlohmann::json json ) : json( std::move( json ) ) {}
 
      public:
        [[nodiscard]] const nlohmann::json& asJson() const & { return json; }
        [[nodiscard]] nlohmann::json&& asJson() && { return std::move( json ); }
    };

    struct Number : Base
    {
        Number()
            : Base( nlohmann::json::object( {
                { "type", "number" },
            } ) )
        {}
    };

    struct String : Base
    {
        String()
            : Base( nlohmann::json::object( {
                { "type", "string" },
            } ) )
        {}
    };

    struct Bool : Base
    {
        Bool()
            : Base( nlohmann::json::object( {
                { "type", "boolean" },
            } ) )
        {}
    };

    struct Array : Base
    {
        Array( Base elemSchema )
            : Base( nlohmann::json::object( {
                { "type", "array" },
                { "items", std::move( elemSchema ).asJson() },
            } ) )
        {}
    };

    struct Object : Base
    {
        Object()
            : Base( nlohmann::json::object( {
                { "type", "object" },
                { "properties", nlohmann::json::object() },
                { "required", nlohmann::json::array() },
            } ) )
        {}

        Object &addMember( std::string name, Base schema ) &
        {
            json.at("required").push_back( name );
            addMemberOpt( std::move( name ), std::move( schema ) );
            return *this;
        }

        Object &addMemberOpt( std::string name, Base schema ) &
        {
            json.at( "properties" ).push_back( nlohmann::json::object_t::value_type( std::move( name ), std::move( schema ).asJson() ) );
            return *this;
        }

        [[nodiscard]] Object&& addMember( std::string name, Base schema ) &&
        {
            addMember( std::move( name ), std::move( schema ) );
            return std::move( *this );
        }

        [[nodiscard]] Object&& addMemberOpt( std::string name, Base schema ) &&
        {
            addMemberOpt( std::move( name ), std::move( schema ) );
            return std::move( *this );
        }
    };
}

class Server
{
public:
    struct Params
    {
        std::string address = "127.0.0.1"; 
        int port = 7887;
        std::string name; 
        std::string version; 
 
        friend bool operator==( const Params&, const Params& ) = default;
 
        MRMCP_API Params();
    };
 
    MRMCP_API Server();
    MRMCP_API Server( Server&& );
    MRMCP_API Server& operator=( Server&& );
    MRMCP_API ~Server();

    using ToolFunc = std::function<nlohmann::json( const nlohmann::json& args )>;

    MRMCP_API bool addTool( std::string id, std::string name, std::string desc, Schema::Base inputSchema, Schema::Base outputSchema, ToolFunc func );
 
    [[nodiscard]] MRMCP_API const Params& getParams() const;

    MRMCP_API void setParams( Params params );
 
    [[nodiscard]] MRMCP_API bool isRunning() const;
    MRMCP_API bool setRunning( bool enable );

    MRMCP_API void shutdown();

    [[nodiscard]] MRMCP_API nlohmann::json dumpToolsAsJson() const;

    MRMCP_API Expected<void> saveToolsCache( const std::filesystem::path& path ) const;

    using ToolValidator = std::function<Expected<void>( const std::string& toolId )>;
    MRMCP_API void setToolValidator( ToolValidator validator );
 
private:
    struct State;

    std::unique_ptr<State> state_;
 
    Params params_;
};

[[nodiscard]] MRMCP_API Server& getDefaultServer();
 
}