lex-knowledge 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ea1661f154fc5184b961caac74654775240dcc49fd7d8c6be469f6cd5520429c
+  data.tar.gz: 3499bcb535edb1f56e896ed9c462a2cfabb9d7d1804dc55ecd559fc3b1941ae9
+SHA512:
+  metadata.gz: 8b50acc322c82ae7629e5152e31c84ce9b348fdd1226e96aa7bc3c1f9f67cd330b809212f49c19636d93a45a199ce4e936a3d172cf71997ffad5aa69eb9712ef
+  data.tar.gz: c1feac59942cf706beb303cbac9989e569937048d2f666af3e762ef50d69659c46de6bb350f69cc16a5103581d54682c3f68886f84a4a840b16b1f0e8cfb82e6

data/README.md

@@ -0,0 +1,77 @@
+# lex-knowledge
+
+Document corpus ingestion and knowledge query pipeline for LegionIO.
+
+`lex-knowledge` walks a directory of documents, parses them into sections, splits sections into token-aware chunks, and writes each chunk to Apollo as a searchable knowledge entry. A query runner retrieves relevant chunks via semantic search and optionally synthesizes an answer through the LLM pipeline.
+
+## Phase A: Corpus Ingestion
+
+This gem implements Phase A of the knowledge pipeline:
+
+- **Manifest**: file walker with SHA256 fingerprinting and incremental diff support
+- **Parser**: section-aware extraction for Markdown and plain text
+- **Chunker**: paragraph-respecting splits with configurable token budget and overlap
+- **Ingest runners**: full corpus or single-file ingestion, writing chunks to Apollo
+- **Query runners**: retrieval-only or retrieval + LLM synthesis
+
+`.docx` and `.pdf` parsing are deferred to a later phase.
+
+## Usage
+
+```ruby
+require 'legion/extensions/knowledge'
+
+# Ingest an entire directory
+Legion::Extensions::Knowledge::Runners::Ingest.ingest_corpus(
+  path:    '/path/to/docs',
+  dry_run: false,
+  force:   false
+)
+# => { success: true, files_scanned: 12, chunks_created: 84, chunks_skipped: 0, chunks_updated: 0 }
+
+# Ingest a single file
+Legion::Extensions::Knowledge::Runners::Ingest.ingest_file(
+  file_path: '/path/to/docs/guide.md'
+)
+# => { success: true, file: '...', chunks_created: 7, chunks_skipped: 0, chunks_updated: 0 }
+
+# Query with LLM synthesis
+Legion::Extensions::Knowledge::Runners::Query.query(
+  question:   'How does Legion route tasks?',
+  top_k:      5,
+  synthesize: true
+)
+# => { success: true, answer: '...', sources: [...], metadata: { retrieval_score: 0.87, chunk_count: 5, latency_ms: 312 } }
+
+# Retrieval only (no LLM)
+Legion::Extensions::Knowledge::Runners::Query.retrieve(
+  question: 'What is a LEX extension?',
+  top_k:    3
+)
+# => { success: true, sources: [...], metadata: { chunk_count: 3 } }
+```
+
+## Configuration
+
+Settings are read from `Legion::Settings` under the `:knowledge` key:
+
+```yaml
+knowledge:
+  chunker:
+    max_tokens: 512      # default 512
+    overlap_tokens: 128  # default 128
+  query:
+    top_k: 5             # default 5
+```
+
+## Dependencies
+
+- `legion-cache`, `legion-crypt`, `legion-data`, `legion-json`, `legion-logging`, `legion-settings`, `legion-transport`
+- `lex-apollo` (optional): chunk storage and vector retrieval
+- `legion-llm` (optional): answer synthesis
+
+Both optional dependencies are guarded with `defined?()` — the gem degrades gracefully when they are absent.
+
+## License
+
+MIT

data/lib/legion/extensions/knowledge/client.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Knowledge
+      class Client
+        include Runners::Ingest
+        include Runners::Query
+        include Runners::Corpus
+      end
+    end
+  end
+end

data/lib/legion/extensions/knowledge/helpers/chunker.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Legion
+  module Extensions
+    module Knowledge
+      module Helpers
+        module Chunker
+          CHARS_PER_TOKEN = 4
+
+          module_function
+
+          def chunk(sections:, max_tokens: nil, overlap_tokens: nil)
+            resolved_max     = max_tokens     || settings_max_tokens     || 512
+            resolved_overlap = overlap_tokens || settings_overlap_tokens || 128
+
+            max_chars     = resolved_max * CHARS_PER_TOKEN
+            overlap_chars = resolved_overlap * CHARS_PER_TOKEN
+
+            chunks = []
+            sections.each do |section|
+              chunks.concat(split_section(section, max_chars, overlap_chars))
+            end
+            chunks
+          end
+
+          def split_section(section, max_chars, overlap_chars)
+            paragraphs = section[:content].split(/\n\n+/)
+            chunks     = []
+            buffer     = ''
+            chunk_idx  = 0
+
+            paragraphs.each do |para|
+              candidate = buffer.empty? ? para : "#{buffer}\n\n#{para}"
+
+              if candidate.length <= max_chars
+                buffer = candidate
+              else
+                unless buffer.empty?
+                  chunks << build_chunk(section, buffer, chunk_idx)
+                  chunk_idx += 1
+                  tail   = buffer.length > overlap_chars ? buffer[-overlap_chars..] : buffer
+                  buffer = tail.empty? ? para : "#{tail}\n\n#{para}"
+                end
+
+                if para.length > max_chars
+                  para.chars.each_slice(max_chars).with_index do |slice, i|
+                    text = slice.join
+                    chunks << build_chunk(section, text, chunk_idx + i)
+                  end
+                  chunk_idx += (para.length.to_f / max_chars).ceil
+                  buffer = ''
+                else
+                  buffer = para
+                end
+              end
+            end
+
+            chunks << build_chunk(section, buffer, chunk_idx) unless buffer.empty?
+            chunks
+          end
+          private_class_method :split_section
+
+          def build_chunk(section, content, index)
+            {
+              content:      content,
+              heading:      section[:heading],
+              section_path: section[:section_path],
+              source_file:  section[:source_file],
+              token_count:  (content.length.to_f / CHARS_PER_TOKEN).ceil,
+              chunk_index:  index,
+              content_hash: ::Digest::SHA256.hexdigest(content)
+            }
+          end
+          private_class_method :build_chunk
+
+          def settings_max_tokens
+            return nil unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:knowledge, :chunker, :max_tokens)
+          rescue StandardError
+            nil
+          end
+          private_class_method :settings_max_tokens
+
+          def settings_overlap_tokens
+            return nil unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:knowledge, :chunker, :overlap_tokens)
+          rescue StandardError
+            nil
+          end
+          private_class_method :settings_overlap_tokens
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/knowledge/helpers/manifest.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'find'
+
+module Legion
+  module Extensions
+    module Knowledge
+      module Helpers
+        module Manifest
+          module_function
+
+          def scan(path:, extensions: %w[.md .txt .docx .pdf])
+            results = []
+
+            Find.find(path) do |entry|
+              basename = ::File.basename(entry)
+              Find.prune if basename.start_with?('.')
+
+              next unless ::File.file?(entry)
+              next unless extensions.include?(::File.extname(entry).downcase)
+
+              results << build_entry(entry)
+            end
+
+            results
+          end
+
+          def diff(current:, previous:)
+            current_map  = current.to_h { |e| [e[:path], e[:sha256]] }
+            previous_map = previous.to_h { |e| [e[:path], e[:sha256]] }
+
+            added   = current_map.keys - previous_map.keys
+            removed = previous_map.keys - current_map.keys
+            changed = current_map.keys.select do |p|
+              previous_map.key?(p) && previous_map[p] != current_map[p]
+            end
+
+            { added: added, changed: changed, removed: removed }
+          end
+
+          def build_entry(path)
+            {
+              path:   path,
+              size:   ::File.size(path),
+              mtime:  ::File.mtime(path),
+              sha256: ::Digest::SHA256.file(path).hexdigest
+            }
+          end
+          private_class_method :build_entry
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/knowledge/helpers/parser.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Knowledge
+      module Helpers
+        module Parser
+          module_function
+
+          def parse(file_path:)
+            ext = ::File.extname(file_path).downcase
+
+            case ext
+            when '.md'
+              parse_markdown(file_path: file_path)
+            when '.txt'
+              parse_text(file_path: file_path)
+            else
+              [{ error: 'unsupported format', source_file: file_path }]
+            end
+          end
+
+          def parse_markdown(file_path:)
+            content = ::File.read(file_path, encoding: 'utf-8')
+            sections = []
+            current_heading = ::File.basename(file_path, '.*')
+            current_lines   = []
+            section_path    = []
+
+            content.each_line do |line|
+              if line.start_with?('# ')
+                flush_section(sections, current_heading, section_path, current_lines, file_path) unless current_lines.empty?
+                current_heading = line.sub(/^#+\s*/, '').chomp
+                section_path    = [current_heading]
+                current_lines   = []
+              elsif line.start_with?('## ')
+                flush_section(sections, current_heading, section_path, current_lines, file_path) unless current_lines.empty?
+                current_heading = line.sub(/^#+\s*/, '').chomp
+                section_path    = section_path.first(1) + [current_heading]
+                current_lines   = []
+              else
+                current_lines << line
+              end
+            end
+
+            flush_section(sections, current_heading, section_path, current_lines, file_path) unless current_lines.empty?
+
+            sections.empty? ? [{ heading: ::File.basename(file_path, '.*'), section_path: [], content: content.strip, source_file: file_path }] : sections
+          end
+
+          def parse_text(file_path:)
+            content = ::File.read(file_path, encoding: 'utf-8')
+            heading = ::File.basename(file_path, '.*')
+
+            [{ heading: heading, section_path: [], content: content.strip, source_file: file_path }]
+          end
+
+          def flush_section(sections, heading, section_path, lines, file_path)
+            content = lines.join.strip
+            return if content.empty?
+
+            sections << {
+              heading:      heading,
+              section_path: section_path.dup,
+              content:      content,
+              source_file:  file_path
+            }
+          end
+          private_class_method :flush_section
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/knowledge/runners/corpus.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Knowledge
+      module Runners
+        module Corpus
+          module_function
+
+          def corpus_stats
+            { success: true, info: 'not yet implemented' }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/knowledge/runners/ingest.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Knowledge
+      module Runners
+        module Ingest
+          module_function
+
+          def scan_corpus(path:, extensions: nil)
+            opts = { path: path }
+            opts[:extensions] = extensions if extensions
+
+            entries = Helpers::Manifest.scan(**opts)
+
+            {
+              success:     true,
+              path:        path,
+              file_count:  entries.size,
+              total_bytes: entries.sum { |e| e[:size] },
+              files:       entries.map { |e| e[:path] }
+            }
+          end
+
+          def ingest_corpus(path:, dry_run: false, force: false)
+            entries = Helpers::Manifest.scan(path: path)
+
+            files_scanned   = entries.size
+            chunks_created  = 0
+            chunks_skipped  = 0
+            chunks_updated  = 0
+
+            entries.each do |entry|
+              result = process_file(entry[:path], dry_run: dry_run, force: force)
+              chunks_created  += result[:created]
+              chunks_skipped  += result[:skipped]
+              chunks_updated  += result[:updated]
+            end
+
+            {
+              success:        true,
+              files_scanned:  files_scanned,
+              chunks_created: chunks_created,
+              chunks_skipped: chunks_skipped,
+              chunks_updated: chunks_updated
+            }
+          rescue StandardError => e
+            { success: false, error: e.message }
+          end
+
+          def ingest_file(file_path:, force: false)
+            result = process_file(file_path, dry_run: false, force: force)
+
+            {
+              success:        true,
+              file:           file_path,
+              chunks_created: result[:created],
+              chunks_skipped: result[:skipped],
+              chunks_updated: result[:updated]
+            }
+          rescue StandardError => e
+            { success: false, error: e.message }
+          end
+
+          def process_file(file_path, dry_run: false, force: false)
+            sections = Helpers::Parser.parse(file_path: file_path)
+            return { created: 0, skipped: 0, updated: 0 } if sections.first&.key?(:error)
+
+            chunks  = Helpers::Chunker.chunk(sections: sections)
+            created = 0
+            skipped = 0
+            updated = 0
+
+            chunks.each do |chunk|
+              outcome = upsert_chunk(chunk, dry_run: dry_run, force: force)
+              case outcome
+              when :created then created += 1
+              when :skipped then skipped += 1
+              when :updated then updated += 1
+              end
+            end
+
+            { created: created, skipped: skipped, updated: updated }
+          end
+          private_class_method :process_file
+
+          def upsert_chunk(chunk, dry_run: false, force: false)
+            return :created if dry_run
+
+            return :created unless defined?(Legion::Extensions::Apollo)
+
+            return :skipped if !force && chunk_exists?(chunk[:content_hash])
+
+            embedding = generate_embedding(chunk[:content])
+            ingest_to_apollo(chunk, embedding)
+
+            force ? :updated : :created
+          rescue StandardError
+            :skipped
+          end
+          private_class_method :upsert_chunk
+
+          def chunk_exists?(content_hash)
+            return false unless defined?(Legion::Extensions::Apollo)
+
+            Legion::Extensions::Apollo::Runners::Knowledge.retrieve_relevant(
+              query:  content_hash,
+              limit:  1,
+              tags:   ['document_chunk'],
+              filter: { content_hash: content_hash }
+            ).any?
+          rescue StandardError
+            false
+          end
+          private_class_method :chunk_exists?
+
+          def generate_embedding(content)
+            return nil unless defined?(Legion::Extensions::Apollo)
+            return nil unless defined?(Legion::Extensions::Apollo::Helpers::Embedding)
+
+            Legion::Extensions::Apollo::Helpers::Embedding.generate(content)
+          rescue StandardError
+            nil
+          end
+          private_class_method :generate_embedding
+
+          def ingest_to_apollo(chunk, embedding)
+            return unless defined?(Legion::Extensions::Apollo)
+
+            payload = {
+              content:      chunk[:content],
+              content_type: 'document_chunk',
+              content_hash: chunk[:content_hash],
+              tags:         [chunk[:source_file], chunk[:heading], 'document_chunk'].compact.uniq,
+              metadata:     {
+                source_file:  chunk[:source_file],
+                heading:      chunk[:heading],
+                section_path: chunk[:section_path],
+                chunk_index:  chunk[:chunk_index],
+                token_count:  chunk[:token_count]
+              }
+            }
+            payload[:embedding] = embedding if embedding
+
+            Legion::Extensions::Apollo::Runners::Knowledge.handle_ingest(**payload)
+          end
+          private_class_method :ingest_to_apollo
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/knowledge/runners/query.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Knowledge
+      module Runners
+        module Query
+          module_function
+
+          def query(question:, top_k: nil, synthesize: true)
+            started = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            resolved_k = top_k || settings_top_k || 5
+
+            chunks = retrieve_chunks(question, resolved_k)
+
+            answer = (synthesize_answer(question, chunks) if synthesize && llm_available?)
+
+            latency_ms = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - started) * 1000).round
+
+            {
+              success:  true,
+              answer:   answer,
+              sources:  chunks.map { |c| format_source(c) },
+              metadata: {
+                retrieval_score: average_score(chunks),
+                chunk_count:     chunks.size,
+                latency_ms:      latency_ms
+              }
+            }
+          rescue StandardError => e
+            { success: false, error: e.message }
+          end
+
+          def retrieve(question:, top_k: nil)
+            resolved_k = top_k || settings_top_k || 5
+            chunks     = retrieve_chunks(question, resolved_k)
+
+            {
+              success:  true,
+              sources:  chunks.map { |c| format_source(c) },
+              metadata: {
+                chunk_count: chunks.size
+              }
+            }
+          rescue StandardError => e
+            { success: false, error: e.message }
+          end
+
+          def retrieve_chunks(question, top_k)
+            return [] unless defined?(Legion::Extensions::Apollo)
+
+            Legion::Extensions::Apollo::Runners::Knowledge.retrieve_relevant(
+              query: question,
+              limit: top_k,
+              tags:  ['document_chunk']
+            )
+          rescue StandardError
+            []
+          end
+          private_class_method :retrieve_chunks
+
+          def synthesize_answer(question, chunks)
+            return nil unless llm_available?
+
+            context_text = chunks.map { |c| c[:content] }.join("\n\n---\n\n")
+            prompt = if context_text.empty?
+                       question
+                     else
+                       "You are a helpful assistant. Use the context below to answer the question.\n\n" \
+                         "Context:\n#{context_text}\n\nQuestion: #{question}\n\nAnswer:"
+                     end
+
+            result = Legion::LLM.chat(message: prompt, caller: { extension: 'lex-knowledge' })
+            result.is_a?(Hash) ? result[:content] : result
+          rescue StandardError => e
+            "Error generating answer: #{e.message}"
+          end
+          private_class_method :synthesize_answer
+
+          def format_source(chunk)
+            {
+              content:     chunk[:content],
+              source_file: chunk.dig(:metadata, :source_file) || chunk[:source_file],
+              heading:     chunk.dig(:metadata, :heading)     || chunk[:heading],
+              distance:    chunk[:distance] || chunk[:score]
+            }
+          end
+          private_class_method :format_source
+
+          def average_score(chunks)
+            return nil if chunks.empty?
+
+            scores = chunks.filter_map { |c| c[:distance] || c[:score] }
+            return nil if scores.empty?
+
+            (scores.sum.to_f / scores.size).round(4)
+          end
+          private_class_method :average_score
+
+          def llm_available?
+            defined?(Legion::LLM)
+          end
+          private_class_method :llm_available?
+
+          def settings_top_k
+            return nil unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:knowledge, :query, :top_k)
+          rescue StandardError
+            nil
+          end
+          private_class_method :settings_top_k
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/knowledge/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Knowledge
+      VERSION = '0.1.2'
+    end
+  end
+end

data/lib/legion/extensions/knowledge.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'knowledge/version'
+require_relative 'knowledge/helpers/manifest'
+require_relative 'knowledge/helpers/parser'
+require_relative 'knowledge/helpers/chunker'
+require_relative 'knowledge/runners/ingest'
+require_relative 'knowledge/runners/query'
+require_relative 'knowledge/runners/corpus'
+require_relative 'knowledge/client'
+
+module Legion
+  module Extensions
+    module Knowledge
+      extend Legion::Extensions::Core if defined?(Legion::Extensions::Core)
+    end
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: lex-knowledge
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Matthew Iverson
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.13
+- !ruby/object:Gem::Dependency
+  name: legion-crypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+- !ruby/object:Gem::Dependency
+  name: legion-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.15
+- !ruby/object:Gem::Dependency
+  name: legion-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+description: Document corpus ingestion and knowledge query pipeline for LegionIO
+email:
+- matt@iverson.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/legion/extensions/knowledge.rb
+- lib/legion/extensions/knowledge/client.rb
+- lib/legion/extensions/knowledge/helpers/chunker.rb
+- lib/legion/extensions/knowledge/helpers/manifest.rb
+- lib/legion/extensions/knowledge/helpers/parser.rb
+- lib/legion/extensions/knowledge/runners/corpus.rb
+- lib/legion/extensions/knowledge/runners/ingest.rb
+- lib/legion/extensions/knowledge/runners/query.rb
+- lib/legion/extensions/knowledge/version.rb
+homepage: https://github.com/LegionIO/lex-knowledge
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Document corpus ingestion and knowledge query pipeline for LegionIO
+test_files: []