Class: Igniter::Store::MCPAdapter

Inherits:
Object
  • Object
show all
Defined in:
lib/igniter/store/mcp_adapter.rb

Overview

Read-only MCP adapter over Store Open Protocol.

Every tool call lowers to a Protocol::Interpreter method or a named protocol metadata view. The adapter never touches backends directly, never executes Igniter contracts, and never evaluates Ruby DSL.

Usage — embedded (local store):

store   = Igniter::Store.segmented(root_dir)
adapter = Igniter::Store::MCPAdapter.new(store)
result  = adapter.call_tool(:query, store: "tasks", where: {}, limit: 50)

Usage — wrap an existing Interpreter:

adapter = Igniter::Store::MCPAdapter.new(proto)  # proto = Protocol::Interpreter

Usage — remote StoreServer /v1/dispatch:

adapter = Igniter::Store::MCPAdapter.remote("http://127.0.0.1:7300/v1/dispatch")

Every response includes:

schema_version, request_id, source_protocol_op, status, result | error

Mutating tools (write_fact, register_descriptor, compact, checkpoint) are disabled by default and require an explicit :enabled_tools list.

Defined Under Namespace

Classes: RemoteDispatch

Constant Summary collapse

SCHEMA_VERSION = 
1
READ_TOOLS = 
%i[
  metadata_snapshot
  descriptor_snapshot
  observability_snapshot
  read
  query
  resolve
  causation_chain
  lineage
  fact_ref
  replay
  sync_profile
  storage_stats
  segment_manifest
  compaction_activity
].freeze
TOOL_TO_OP = 
{
  metadata_snapshot:      :metadata_snapshot,
  descriptor_snapshot:    :descriptor_snapshot,
  observability_snapshot: :observability_snapshot,
  read:                   :read,
  query:                  :query,
  resolve:                :resolve,
  causation_chain:        :causation_chain,
  lineage:                :lineage,
  fact_ref:               :fact_ref,
  replay:                 :replay,
  sync_profile:           :sync_hub_profile,
  storage_stats:          :storage_stats,
  segment_manifest:       :segment_manifest,
  compaction_activity:    :compaction_activity
}.freeze

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(interpreter_or_store, enabled_tools: READ_TOOLS) ⇒ MCPAdapter

interpreter_or_store — Protocol::Interpreter, IgniterStore, or a store

returned by Igniter::Store.segmented / Igniter::Store.memory.

enabled_tools — Array of tool name Symbols. Defaults to READ_TOOLS.



117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/igniter/store/mcp_adapter.rb', line 117

def initialize(interpreter_or_store, enabled_tools: READ_TOOLS)
  @interpreter = case interpreter_or_store
                 when Protocol::Interpreter
                   interpreter_or_store
                 when IgniterStore
                   Protocol::Interpreter.new(interpreter_or_store)
                 when RemoteDispatch
                   interpreter_or_store
                 else
                   raise ArgumentError,
                         "MCPAdapter expects a Protocol::Interpreter, IgniterStore, or RemoteDispatch, " \
                         "got #{interpreter_or_store.class}"
                 end
  @remote = interpreter_or_store.is_a?(RemoteDispatch)
  @enabled = enabled_tools.map(&:to_sym).to_set
end

Class Method Details

.remote(endpoint, enabled_tools: READ_TOOLS) ⇒ Object 



110
111
112
 
# File 'lib/igniter/store/mcp_adapter.rb', line 110

def self.remote(endpoint, enabled_tools: READ_TOOLS)
  new(RemoteDispatch.new(endpoint), enabled_tools: enabled_tools)
end

Instance Method Details

#call_tool(name, arguments = {}) ⇒ Object

Call a named tool with an arguments Hash (symbol or string keys). Returns a response Hash with schema_version, request_id, status, etc. Never raises — errors are captured into the response envelope.



142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/igniter/store/mcp_adapter.rb', line 142

def call_tool(name, arguments = {})
  tool = nil
  req = nil
  tool = name.to_sym
  args = arguments.transform_keys(&:to_sym)
  req  = args.delete(:request_id) || generate_request_id

  unless @enabled.include?(tool)
    return error_response(tool, req, "Tool #{tool.inspect} is not enabled")
  end

  result = dispatch(tool, args, request_id: req)
  ok_response(tool, req, result)
rescue ArgumentError => e
  error_response(tool, req || generate_request_id, e.message)
rescue StandardError => e
  error_response(tool, req || generate_request_id, "Internal error: #{e.message}")
end

#tool_list ⇒ Object

Returns an Array of tool schema Hashes (name + description + input_schema).



135
136
137
 
# File 'lib/igniter/store/mcp_adapter.rb', line 135

def tool_list
  READ_TOOLS.select { |t| @enabled.include?(t) }.map { |t| tool_schema(t) }
end