rasti-ai 1.0.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9410e72e90cbc69453db4573c4ea4f611719feafc816c389f0490fe003f5f7ee
-  data.tar.gz: 3e5776057dd26b4adf2a138d94511a79a88fa55418ca0b2c834aeb62ada9d70f
+  metadata.gz: f62b3decd7ee67906392eff6218e29fd8a66bee1f5dc41729e4412193f7ff4d0
+  data.tar.gz: 3368912d5ee86e2ba10408aa4795c97820b8f313a6d17d693deca2f0454ad9e8
 SHA512:
-  metadata.gz: 889f7e24c2438cba3e7f434e6d1578c734a0bbc6b2ef867da7ee8a74a69d6b6451c4c20da3bc34944f4b2113d679991fb3aa40f761e285266ad6d3cb4a0881ae
-  data.tar.gz: ddafe4e189697dfcc5980da19bb9339387867f1ceacab79fa4f74aba50ebf84d92754863c066e2db86586d7dd637075ce7fd36ced4ea948ca59c67b09f88aba7
+  metadata.gz: da0b274e1ed8e4d4c0d9d4f7867ca546f47bc13c48246e111a71f465719237abf11985384699097f19d61822a33575fdd2a3398c63b2bb12a4612b11e563cec6
+  data.tar.gz: 48618afd26f383ff8c38d7527c3aac4f44015c9812677c93a893c7d9ccbddc0ed8cd4f6ebb6309acac3c334effaffec6138fb72715f036a51083839129f44cab

data/.gitignore

@@ -7,4 +7,5 @@
 /pkg/
 /spec/reports/
 /tmp/
-/.ruby-env
+/.ruby-env
+/log/*.log

data/README.md

@@ -96,12 +96,160 @@ state.messages
 # ]
 ```
 
+### MCP (Model Context Protocol)
+
+Rasti::AI includes support for the Model Context Protocol, allowing you to create MCP servers and clients for tool communication.
+
+#### MCP Server
+
+The MCP Server acts as a Rack middleware that exposes registered tools through a JSON-RPC 2.0 interface.
+
+##### Configuration
+
+```ruby
+Rasti::AI::MCP::Server.configure do |config|
+  config.server_name = 'My MCP Server'
+  config.server_version = '1.0.0'
+  config.relative_path = '/mcp' # Default endpoint path
+end
+```
+
+##### Registering Tools
+
+Tools must inherit from `Rasti::AI::Tool` and can be registered with the server:
+
+```ruby
+class HelloWorldTool < Rasti::AI::Tool
+  def self.description
+    'Returns a hello world message'
+  end
+
+  def execute(form)
+    {text: 'Hello world'}
+  end
+end
+
+class SumTool < Rasti::AI::Tool
+  class Form < Rasti::Form
+    attribute :number_a, Rasti::Types::Float
+    attribute :number_b, Rasti::Types::Float
+  end
+
+  def execute(form)
+    {result: form.number_a + form.number_b}
+  end
+end
+
+# Register tools
+Rasti::AI::MCP::Server.register_tool HelloWorldTool.new
+Rasti::AI::MCP::Server.register_tool SumTool.new
+```
+
+##### Using as Rack Middleware
+
+```ruby
+# In your config.ru
+require 'rasti/ai'
+
+# Register your tools
+Rasti::AI::MCP::Server.register_tool HelloWorldTool.new
+Rasti::AI::MCP::Server.register_tool SumTool.new
+
+# Use as middleware
+use Rasti::AI::MCP::Server
+
+run YourApp
+```
+
+The server will handle POST requests to the configured path (`/mcp` by default) and pass all other requests to your application.
+
+##### Supported MCP Methods
+
+- `initialize` - Returns protocol version and server capabilities
+- `tools/list` - Returns all registered tools with their schemas
+- `tools/call` - Executes a specific tool with provided arguments
+
+#### MCP Client
+
+The MCP Client allows you to communicate with MCP servers.
+
+##### Basic Usage
+
+```ruby
+# Create a client
+client = Rasti::AI::MCP::Client.new(
+  url: 'https://mcp.server.ai/mcp'
+)
+
+# List available tools
+tools = client.list_tools
+# => [
+#      { "name" => "hello_world_tool", "description" => "Hello World", ... },
+#      { "name" => "sum_tool", "description" => "Sum two numbers", ... }
+#    ]
+
+# Call a tool
+result = client.call_tool 'sum_tool', number_a: 5, number_b: 3
+# => '{"type":"text","text":"{\"result\":8.0}"}'
+
+result = client.call_tool 'hello_world_tool'
+# => '{"type":"text","text":"{\"text\":\"Hello world\"}"}'
+```
+
+##### Restricting Available Tools
+
+You can restrict which tools the client can access:
+
+```ruby
+client = Rasti::AI::MCP::Client.new(
+  url: 'https://mcp.server.ai/mcp',
+  allowed_tools: ['sum_tool', 'multiply_tool']
+)
+
+# Only returns allowed tools
+tools = client.list_tools
+# => [{ "name" => "sum_tool", ... }]
+
+# Calling a non-allowed tool raises an error
+client.call_tool 'hello_world_tool'
+# => RuntimeError: Invalid tool: hello_world_tool
+```
+
+##### Custom Logger
+
+```ruby
+client = Rasti::AI::MCP::Client.new(
+  url: 'https://mcp.server.ai/mcp',
+  logger: Logger.new(STDOUT)
+)
+```
+
+##### Integration with OpenAI Assistant
+
+You can use MCP clients as tools for the OpenAI Assistant:
+
+```ruby
+# Create an MCP client
+mcp_client = Rasti::AI::MCP::Client.new(
+  url: 'https://mcp.server.ai/mcp'
+)
+
+# Use it with the assistant
+assistant = Rasti::AI::OpenAI::Assistant.new(
+  mcp_servers: {
+    my_mcp: mcp_client
+  }
+)
+
+# The assistant can now call tools from the MCP server
+assistant.call 'What is 5 plus 3?'
+# The assistant will use the sum_tool from the MCP server
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/gabynaiman/rasti-ai.
 
-
 ## License
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/rasti/ai/mcp/client.rb

@@ -0,0 +1,68 @@
+module Rasti
+  module AI
+    module MCP
+      class Client
+
+        def initialize(url:, allowed_tools:nil, logger:nil)
+          @url = url
+          @allowed_tools = allowed_tools
+          @logger = logger || Rasti::AI.logger
+        end
+
+        def list_tools
+          result = request_mcp 'tools/list'
+          tools = result['tools']
+          if allowed_tools
+            tools.select { |tool| allowed_tools.include? tool['name'] }
+          else
+            tools
+          end
+        end
+
+        def call_tool(name, arguments={})
+          raise "Invalid tool: #{name}" if allowed_tools && !allowed_tools.include?(name)
+          result = request_mcp 'tools/call', name: name, arguments: arguments
+          JSON.dump result['content'][0]
+        end
+
+        private
+
+        attr_reader :url, :allowed_tools, :logger
+
+        def request_mcp(method, params={})
+          uri = URI.parse url
+
+          http = Net::HTTP.new uri.host, uri.port
+          http.use_ssl = uri.scheme == 'https'
+
+          request = Net::HTTP::Post.new uri.path
+
+          request['Content-Type'] = 'application/json'
+
+          body = {
+            jsonrpc: '2.0',
+            method: method,
+            params: params
+          }
+          request.body = JSON.dump body
+
+          logger.info(self.class) { "POST #{url} -> #{method}" }
+          logger.debug(self.class) { JSON.pretty_generate(params) }
+          
+          response = http.request request
+
+          logger.info(self.class) { "Response #{response.code}" }
+          logger.debug(self.class) { response.body }
+
+          json = JSON.parse response.body
+
+          raise "MCP Error: #{json['error']['message']}" if json['error']
+          raise "MCP Error: invalid result" unless json['result']
+
+          json['result']
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/ai/mcp/errors.rb

@@ -0,0 +1,29 @@
+module Rasti
+  module AI
+    module MCP
+
+      # JSON-RPC oficiales
+      JSON_RPC_PARSE_ERROR               = -32700
+      JSON_RPC_INVALID_REQUEST           = -32600
+      JSON_RPC_METHOD_NOT_FOUND          = -32601
+      JSON_RPC_INVALID_PARAMS            = -32602
+      JSON_RPC_INTERNAL_ERROR            = -32603
+
+      # JSON-RPC rango de servidor (permitido)
+      JSON_RPC_SERVER_ERROR              = -32000
+      JSON_RPC_SERVER_NOT_FOUND          = -32001
+      JSON_RPC_SERVER_UNAUTHORIZED       = -32002
+      JSON_RPC_SERVER_FORBIDDEN          = -32003
+      JSON_RPC_SERVER_RESOURCE_NOT_FOUND = -32004
+      JSON_RPC_SERVER_RATE_LIMIT         = -32005
+
+      # MCP (usos comunes)
+      MCP_INVALID_ACCESS                 = -32001
+      MCP_TOOL_ERROR                     = -32002
+      MCP_FETCH_ERROR                    = -32003
+      MCP_RESOURCE_NOT_FOUND             = -32004
+      MCP_TIMEOUT                        = -32005
+
+    end
+  end
+end

data/lib/rasti/ai/mcp/server.rb

@@ -0,0 +1,156 @@
+module Rasti
+  module AI
+    module MCP
+      class Server
+
+        ToolSpecification = Rasti::Model[:tool, :serialization]
+
+        PROTOCOL_VERSION = '2024-11-05'.freeze
+        JSON_RPC_VERSION = '2.0'.freeze
+
+        extend ClassConfig
+
+        attr_config :server_name, 'MCP Server'
+        attr_config :server_version, '1.0.0'
+        attr_config :relative_path, '/mcp'
+        
+        class << self
+
+          def register_tool(tool)
+            serialization = ToolSerializer.serialize tool.class
+            raise "Tool #{serialization[:name]} already exist" if tools.key? serialization[:name]
+            tools[serialization[:name]] = ToolSpecification.new tool: tool, serialization: serialization
+          end
+
+          def clear_tools
+            tools.clear
+          end
+
+          def tools_serializations
+            tools.values.map(&:serialization)
+          end
+
+          def call_tool(name, arguments={})
+            raise "Tool #{name} not found" unless tools.key? name
+            tools[name].tool.call arguments
+          end
+
+          private
+
+          def tools
+            @tools ||= {}
+          end
+
+        end
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          request = Rack::Request.new env
+          
+          if request.post? && request.path == self.class.relative_path
+            handle_mcp_request request
+          else
+            app.call env
+          end
+        end
+
+        private
+
+        attr_reader :app
+
+        def handle_mcp_request(request)
+          body = request.body.read
+          data = JSON.parse body
+          
+          response = case data['method']
+          when 'initialize'
+            handle_initialize data
+          when 'tools/list'
+            handle_tools_list data
+          when 'tools/call'
+            handle_tool_call data
+          else
+            error_response data['id'], JSON_RPC_METHOD_NOT_FOUND, 'Method not found'
+          end
+          
+          [200, {'Content-Type' => 'application/json'}, [JSON.dump(response)]]
+
+        rescue JSON::ParserError => e
+          response = error_response nil, JSON_RPC_PARSE_ERROR, e.message
+          [400, {'Content-Type' => 'application/json'}, [JSON.dump(response)]]
+          
+        rescue => e
+          response = error_response nil, JSON_RPC_INTERNAL_ERROR, e.message
+          [500, {'Content-Type' => 'application/json'}, [JSON.dump(response)]]
+        end
+        
+        def handle_initialize(data)
+          {
+            jsonrpc: JSON_RPC_VERSION,
+            id: data['id'],
+            result: {
+              protocolVersion: PROTOCOL_VERSION,
+              capabilities: {
+                tools: {
+                  list: true,
+                  call: true
+                }
+              },
+              serverInfo: {
+                name: self.class.server_name,
+                version: self.class.server_version
+              }
+            }
+          }
+        end
+        
+        def handle_tools_list(data)
+          {
+            jsonrpc: JSON_RPC_VERSION,
+            id: data['id'],
+            result: {
+              tools: self.class.tools_serializations
+            }
+          }
+        end
+        
+        def handle_tool_call(data)
+          tool_name = data['params']['name']
+          arguments = data['params']['arguments'] || {}
+
+          result = self.class.call_tool tool_name, arguments
+          
+          {
+            jsonrpc: JSON_RPC_VERSION,
+            id: data['id'],
+            result: {
+              content: [
+                {
+                  type: 'text',
+                  text: result
+                }
+              ]
+            }
+          }
+        rescue => e
+          error_response data['id'], JSON_RPC_INTERNAL_ERROR, e.message
+        end
+        
+        def error_response(id, code, message)
+          {
+            jsonrpc: JSON_RPC_VERSION,
+            id: id,
+            error: {
+              code: code,
+              message: message
+            }
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/ai/open_ai/assistant.rb

@@ -5,8 +5,9 @@ module Rasti
 
         attr_reader :state
 
-        def initialize(client:nil, state:nil, model:nil, tools:[], logger:nil)
+        def initialize(client:nil, json_schema:nil, state:nil, model:nil, tools:[], mcp_servers:{}, logger:nil)
           @client = client || Client.new
+          @json_schema = json_schema
           @state = state || AssistantState.new
           @model = model
           @tools = {}
@@ -14,10 +15,20 @@ module Rasti
           @logger = logger || Rasti::AI.logger
 
           tools.each do |tool|
-            serialization = ToolSerializer.serialize tool.class
+            serialization = serialize_tool tool
             @tools[serialization[:function][:name]] = tool
             @serialized_tools << serialization
           end
+
+          mcp_servers.each do |name, mcp|
+            mcp.list_tools.each do |tool|
+              serialization = wrap_tool_serialization tool.merge('name' => "#{name}_#{tool['name']}")
+              @tools["#{name}_#{tool['name']}"] = ->(args) do
+                mcp.call_tool tool['name'], args
+              end
+              @serialized_tools << serialization
+            end
+          end
         end
 
         def call(prompt)
@@ -29,7 +40,8 @@ module Rasti
           loop do
             response = client.chat_completions messages: messages,
                                                model: model,
-                                               tools: serialized_tools
+                                               tools: serialized_tools,
+                                               response_format: response_format
 
             choice = response['choices'][0]['message']
 
@@ -64,12 +76,24 @@ module Rasti
 
         private
 
-        attr_reader :client, :model, :tools, :serialized_tools, :logger
+        attr_reader :client, :json_schema, :model, :tools, :serialized_tools, :logger
 
         def messages
           state.messages
         end
 
+        def serialize_tool(tool)
+          serialization = ToolSerializer.serialize tool.class
+          wrap_tool_serialization serialization
+        end
+
+        def wrap_tool_serialization(serialized_tool)
+          {
+            type: 'function',
+            function: serialized_tool
+          }
+        end
+
         def call_tool(name, args)
           raise Errors::UndefinedTool.new(name) unless tools.key? name
 
@@ -90,6 +114,15 @@ module Rasti
           "Error: #{ex.message}"
         end
 
+        def response_format
+          return nil if json_schema.nil?
+
+          {
+            type: 'json_schema',
+            json_schema: json_schema
+          }
+        end
+
       end
     end
   end

data/lib/rasti/ai/tool.rb

@@ -0,0 +1,23 @@
+module Rasti
+  module AI
+    class Tool
+
+      def self.form
+        constants.include?(:Form) ? const_get(:Form) : Rasti::Form
+      end
+
+      def call(params={})
+        form = self.class.form.new params
+        result = execute form
+        serialize result
+      end
+
+      private
+
+      def serialize(result)
+        JSON.dump result
+      end
+
+    end
+  end
+end

data/lib/rasti/ai/tool_serializer.rb

@@ -0,0 +1,112 @@
+module Rasti
+  module AI
+    class ToolSerializer
+      class << self
+
+        def serialize(tool_class)
+          serialization = {
+            name: serialize_name(tool_class)
+          }
+
+          serialization[:description] = normalize_description(tool_class.description) if tool_class.respond_to? :description
+
+          serialization[:inputSchema] = serialize_form(tool_class.form) if tool_class.respond_to? :form
+
+          serialization
+          
+        rescue => ex
+          raise Errors::ToolSerializationError.new(tool_class), cause: ex
+        end
+
+        private
+
+        def serialize_name(tool_class)
+          Inflecto.underscore Inflecto.demodulize(tool_class.name)
+        end
+
+        def serialize_form(form_class)
+          serialized_attributes = form_class.attributes.each_with_object({}) do |attribute, hash|
+            hash[attribute.name] = serialize_attribute attribute
+          end
+
+          serialization = {
+            type: 'object',
+            properties: serialized_attributes
+          }
+
+          required_attributes = form_class.attributes.select { |a| a.option(:required) }
+
+          serialization[:required] = required_attributes.map(&:name) unless required_attributes.empty?
+
+          serialization
+        end
+
+        def serialize_attribute(attribute)
+          serialization = {}
+          
+          if attribute.option(:description)
+            serialization[:description] = normalize_description attribute.option(:description)
+          end
+          
+          type_serialization = serialize_type attribute.type
+          serialization.merge! type_serialization
+
+          if attribute.type.is_a? Types::Enum
+            values = "#{type_serialization[:enum].join(', ')}"
+            if serialization[:description]
+              serialization[:description] += " (#{values})"
+            else
+              serialization[:description] = values
+            end
+          end
+
+          serialization
+        end
+
+        def serialize_type(type)
+          if type == Types::String
+            {type: 'string'}
+
+          elsif type == Types::Integer
+            {type: 'integer'}
+
+          elsif type == Types::Float
+            {type: 'number'}
+
+          elsif type == Types::Boolean
+            {type: 'boolean'}
+
+          elsif type.is_a? Types::Time
+            {
+              type: 'string',
+              format: 'date'
+            }
+
+          elsif type.is_a? Types::Enum
+            {
+              type: 'string',
+              enum: type.values
+            }
+
+          elsif type.is_a? Types::Array
+            {
+              type: 'array',
+              items: serialize_type(type.type)
+            }
+
+          elsif type.is_a? Types::Model
+            serialize_form(type.model)
+
+          else
+            raise "Type not serializable #{type}"
+          end
+        end
+
+        def normalize_description(description)
+          description.split("\n").map(&:strip).join(' ').strip
+        end
+        
+      end
+    end
+  end
+end

data/lib/rasti/ai/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module AI
-    VERSION = '1.0.1'
+    VERSION = '1.2.0'
   end
 end

data/rasti-ai.gemspec

@@ -24,9 +24,11 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'class_config', '~> 0.0'
 
   spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rack-test', '~> 2.0'
   spec.add_development_dependency 'minitest', '~> 5.0', '< 5.11'
   spec.add_development_dependency 'minitest-colorin', '~> 0.1'
   spec.add_development_dependency 'minitest-line', '~> 0.6'
+  spec.add_development_dependency 'minitest-extended_assertions', '~> 1.0'
   spec.add_development_dependency 'simplecov', '~> 0.12'
   spec.add_development_dependency 'pry-nav', '~> 0.2'
   spec.add_development_dependency 'webmock', '~> 3.0'