dspy 0.2.0 → 0.3.0

data/README.md

@@ -1,77 +1,90 @@
 # DSPy.rb
 
-A Ruby port of the [DSPy library](https://dspy.ai/), enabling a composable and pipeline-oriented approach to programming with Large Language Models (LLMs) in Ruby.
+**Build reliable LLM applications in Ruby using composable, type-safe modules.**
 
-## Current State
+DSPy.rb brings structured LLM programming to Ruby developers.
+Instead of wrestling with prompt strings and parsing responses,
+you define typed signatures and compose them into pipelines that just work.
 
-DSPy.rb provides a foundation for composable LLM programming with the following implemented features:
+Traditional prompting is like writing code with string concatenation: it works until 
+it doesn't. DSPy.rb brings you the programming approach pioneered 
+by [dspy.ai](https://dspy.ai/): instead of crafting fragile prompts, you define 
+modular signatures and let the framework handle the messy details.
 
-- **Signatures**: Define input/output schemas for LLM interactions using JSON schemas
-- **Predict**: Basic LLM completion with structured inputs and outputs
-- **Chain of Thought**: Enhanced reasoning through step-by-step thinking
-- **ReAct**: Compose multiple LLM calls in a structured workflow using tools.
-- **RAG (Retrieval-Augmented Generation)**: Enriched responses with context from retrieval
-- **Multi-stage Pipelines**: Compose multiple LLM calls in a structured workflow
+The result? LLM applications that actually scale and don't break when you sneeze.
 
-The library currently supports:
-- OpenAI and Anthropic via [Ruby LLM](https://github.com/crmne/ruby_llm)
-- JSON schema validation with [dry-schema](https://dry-rb.org/gems/dry-schema/)
+## What You Get
 
-## Installation
+**Core Building Blocks:**
+- **Signatures** - Define input/output schemas using Sorbet types
+- **Predict** - Basic LLM completion with structured data
+- **Chain of Thought** - Step-by-step reasoning for complex problems
+- **ReAct** - Tool-using agents that can actually get things done
+- **RAG** - Context-enriched responses from your data
+- **Multi-stage Pipelines** - Compose multiple LLM calls into workflows
+- OpenAI and Anthropic support via [Ruby LLM](https://github.com/crmne/ruby_llm)
+- Runtime type checking with [Sorbet](https://sorbet.org/)
+- Type-safe tool definitions for ReAct agents
+
+## Fair Warning
+
+This is fresh off the oven and evolving fast. 
+I'm actively building this as a Ruby port of the [DSPy library](https://dspy.ai/). 
+If you hit bugs or want to contribute, just email me directly!
 
-This is not even fresh  off the oven. I recommend you installing 
-it straight from this repo, while I build the first release.
+## What's Next
+These are my goals to release v1.0.
 
+- Solidify prompt optimization
+- OTel Integration
+- Ollama support
+
+## Installation
+
+Skip the gem for now - install straight from this repo while I prep the first release:
 ```ruby
 gem 'dspy', github: 'vicentereig/dspy.rb'
 ```
 
 ## Usage Examples
 
-### Basic Prediction
+### Simple Prediction
 
 ```ruby
 # Define a signature for sentiment classification
 class Classify < DSPy::Signature
   description "Classify sentiment of a given sentence."
 
-  input do
-    required(:sentence).value(:string).meta(description: 'The sentence to analyze')
-  end
-
-  output do
-    required(:sentiment).value(included_in?: %w(positive negative neutral))
-      .meta(description: 'The sentiment classification')
-    required(:confidence).value(:float).meta(description: 'Confidence score')
+  class Sentiment < T::Enum
+    enums do
+      Positive = new('positive')
+      Negative = new('negative')
+      Neutral = new('neutral')
+    end
   end
-end
-
-# Initialize the language model
-class SentimentClassifierWithDescriptions < DSPy::Signature
-  description "Classify sentiment of a given sentence."
 
   input do
-    required(:sentence)
-      .value(:string)
-      .meta(description: 'The sentence whose sentiment you are analyzing')
+    const :sentence, String
   end
 
   output do
-    required(:sentiment)
-      .value(included_in?: [:positive, :negative, :neutral])
-      .meta(description: 'The allowed values to classify sentences')
-
-    required(:confidence).value(:float)
-                         .meta(description:'The confidence score for the classification')
+    const :sentiment, Sentiment
+    const :confidence, Float
   end
 end
+
+# Configure DSPy with your LLM
 DSPy.configure do |c|
   c.lm = DSPy::LM.new('openai/gpt-4o-mini', api_key: ENV['OPENAI_API_KEY'])
 end
+
 # Create the predictor and run inference
 classify = DSPy::Predict.new(Classify)
 result = classify.call(sentence: "This book was super fun to read, though not the last chapter.")
-# => {:confidence=>0.85, :sentence=>"This book was super fun to read, though not the last chapter.", :sentiment=>"positive"}
+
+# result is a properly typed T::Struct instance
+puts result.sentiment    # => #<Sentiment::Positive>  
+puts result.confidence   # => 0.85
 ```
 
 ### Chain of Thought Reasoning
@@ -81,301 +94,397 @@ class AnswerPredictor < DSPy::Signature
   description "Provides a concise answer to the question"
 
   input do
-    required(:question).value(:string)
+    const :question, String
   end
   
   output do
-    required(:answer).value(:string)
+    const :answer, String
   end
 end
 
-DSPy.configure do |c|
-  c.lm = DSPy::LM.new('openai/gpt-4o-mini', api_key: ENV['OPENAI_API_KEY'])
-end
-
+# Chain of thought automatically adds a 'reasoning' field to the output
 qa_cot = DSPy::ChainOfThought.new(AnswerPredictor)
-response = qa_cot.call(question: "Two dice are tossed. What is the probability that the sum equals two?")
-# Result includes reasoning and answer in the response
-# {:question=>"...", :answer=>"1/36", :reasoning=>"There is only one way to get a sum of 2..."}
+result = qa_cot.call(question: "Two dice are tossed. What is the probability that the sum equals two?")
+
+puts result.reasoning  # => "There is only one way to get a sum of 2..."
+puts result.answer     # => "1/36"
 ```
 
-### RAG (Retrieval-Augmented Generation)
+### ReAct Agents with Tools
 
 ```ruby
-class ContextualQA < DSPy::Signature
-  description "Answers questions using relevant context"
-  
+
+class DeepQA < DSPy::Signature
+  description "Answer questions with consideration for the context"
+
   input do
-    required(:context).value(Types::Array.of(:string))
-    required(:question).filled(:string)
+    const :question, String
   end
 
   output do
-    required(:response).filled(:string)
+    const :answer, String
   end
 end
 
-DSPy.configure do |c|
-  c.lm = DSPy::LM.new('openai/gpt-4o-mini', api_key: ENV['OPENAI_API_KEY'])
-end
+# Define tools for the agent
+class CalculatorTool < DSPy::Tools::Base
+
+  tool_name 'calculator'
+  tool_description 'Performs basic arithmetic operations'
+
+  sig { params(operation: String, num1: Float, num2: Float).returns(T.any(Float, String)) }
+  def call(operation:, num1:, num2:)
+    case operation.downcase
+    when 'add' then num1 + num2
+    when 'subtract' then num1 - num2
+    when 'multiply' then num1 * num2
+    when 'divide'
+      return "Error: Cannot divide by zero" if num2 == 0
+      num1 / num2
+    else
+      "Error: Unknown operation '#{operation}'. Use add, subtract, multiply, or divide"
+    end
+  end
 
-# Set up retriever (example using ColBERT)
-retriever = ColBERTv2.new(url: 'http://your-retriever-endpoint')
-# Generate a contextual response
-rag = DSPy::ChainOfThought.new(ContextualQA)
-prediction = rag.call(question: question, context: retriever.call('your query').map(&:long_text))
+# Create ReAct agent with tools
+agent = DSPy::ReAct.new(DeepQA, tools: [CalculatorTool.new])
+
+# Run the agent
+result = agent.forward(question: "What is 42 plus 58?")
+puts result.answer # => "100"
+puts result.history # => Array of reasoning steps and tool calls
 ```
 
-### Multi-stage Pipeline
+### Multi-stage Pipelines
+Outline the sections of an article and draft them out.
 
 ```ruby
-# Create a pipeline for article drafting
+
+# write an article!
+drafter = ArticleDrafter.new
+article = drafter.forward(topic: "The impact of AI on software development") # { title: '....', sections: [{content: '....'}]}
+
+class Outline < DSPy::Signature
+  description "Outline a thorough overview of a topic."
+
+  input do
+    const :topic, String
+  end
+
+  output do
+    const :title, String
+    const :sections, T::Array[String]
+  end
+end
+
+class DraftSection < DSPy::Signature
+  description "Draft a section of an article"
+
+  input do
+    const :topic, String
+    const :title, String
+    const :section, String
+  end
+
+  output do
+    const :content, String
+  end
+end
+
 class ArticleDrafter < DSPy::Module
   def initialize
     @build_outline = DSPy::ChainOfThought.new(Outline)
     @draft_section = DSPy::ChainOfThought.new(DraftSection)
   end
 
-  def forward(topic)
-    # First build the outline
+  def forward(topic:)
     outline = @build_outline.call(topic: topic)
     
-    # Then draft each section
-    sections = []
-    (outline[:section_subheadings] || {}).each do |heading, subheadings|
-      section = @draft_section.call(
-        topic: outline[:title],
-        section_heading: "## #{heading}",
-        section_subheadings: [subheadings].flatten.map { |sh| "### #{sh}" }
+    sections = outline.sections.map do |section|
+      @draft_section.call(
+        topic: topic,
+        title: outline.title,
+        section: section
       )
-      sections << section
     end
 
-    DraftArticle.new(title: outline[:title], sections: sections)
+    {
+      title: outline.title,
+      sections: sections.map(&:content)
+    }
   end
 end
 
-DSPy.configure do |c|
-  c.lm = DSPy::LM.new('openai/gpt-4o-mini', api_key: ENV['OPENAI_API_KEY'])
-end
-# Usage
-drafter = ArticleDrafter.new
-article = drafter.call("World Cup 2002")
 ```
 
-### ReAct: Reasoning and Acting with Tools
+## Working with Complex Types
 
-The `DSPy::ReAct` module implements the ReAct (Reasoning and Acting) paradigm, allowing LLMs to synergize reasoning with tool usage to answer complex questions or complete tasks. The agent iteratively generates thoughts, chooses actions (either calling a tool or finishing), and observes the results to inform its next step.
+### Enums
 
-**Core Components:**
+```ruby
+class Color < T::Enum
+  enums do
+    Red = new
+    Green = new
+    Blue = new
+  end
+end
 
-*   **Signature**: Defines the overall task for the ReAct agent (e.g., answering a question). The output schema of this signature will be augmented by ReAct to include `history` (an array of structured thought/action/observation steps) and `iterations`.
-*   **Tools**: Instances of classes inheriting from `DSPy::Tools::Tool`. Each tool has a `name`, `description` (used by the LLM to decide when to use the tool), and a `call` method that executes the tool's logic.
-*   **LLM**: The ReAct agent internally uses an LLM (configured via `DSPy.configure`) to generate thoughts and decide on actions.
+class ColorSignature < DSPy::Signature
+  description "Identify the dominant color in a description"
 
-**Example 1: Simple Arithmetic with a Tool**
+  input do
+    const :description, String,
+      description: 'Description of an object or scene'
+  end
+
+  output do
+    const :color, Color,
+      description: 'The dominant color (Red, Green, or Blue)'
+  end
+end
+
+predictor = DSPy::Predict.new(ColorSignature)
+result = predictor.call(description: "A red apple on a wooden table")
+puts result.color  # => #<Color::Red>
+```
 
-Let's say we want to answer "What is 5 plus 7?". We can provide the ReAct agent with a simple calculator tool.
+### Optional Fields and Defaults
 
 ```ruby
-# Define a signature for the task
-class MathQA < DSPy::Signature
-  description "Answers mathematical questions."
+class AnalysisSignature < DSPy::Signature
+  description "Analyze text with optional metadata"
 
   input do
-    required(:question).value(:string).meta(description: 'The math question to solve.')
+    const :text, String,
+      description: 'Text to analyze'
+    const :include_metadata, T::Boolean,
+      description: 'Whether to include metadata in analysis',
+      default: false
   end
 
   output do
-    required(:answer).value(:string).meta(description: 'The numerical answer.')
+    const :summary, String,
+      description: 'Summary of the text'
+    const :word_count, Integer,
+      description: 'Number of words (optional)',
+      default: 0
   end
 end
+```
 
-# Define a simple calculator tool
-class CalculatorTool < DSPy::Tools::Tool
-  def initialize
-    super('calculator', 'Calculates the result of a simple arithmetic expression (e.g., "5 + 7"). Input must be a string representing the expression.')
-  end
+## Advanced Usage Patterns
 
-  def call(expression_string)
-    # In a real scenario, you might use a more robust expression parser.
-    # For this example, let's assume simple addition for "X + Y" format.
-    if expression_string.match(/(\d+)\s*\+\s*(\d+)/)
-      num1 = $1.to_i
-      num2 = $2.to_i
-      (num1 + num2).to_s
-    else
-      "Error: Could not parse expression. Use format 'number + number'."
-    end
-  rescue StandardError => e
-    "Error: #{e.message}"
+### Multi-stage Pipelines
+
+```ruby
+class TopicSignature < DSPy::Signature
+  description "Extract main topic from text"
+  
+  input do
+    const :content, String,
+      description: 'Text content to analyze'
+  end
+  
+  output do
+    const :topic, String,
+      description: 'Main topic of the content'
   end
 end
 
-# Configure DSPy (if not already done)
-DSPy.configure do |c|
-  c.lm = DSPy::LM.new('openai/gpt-4o-mini', api_key: ENV['OPENAI_API_KEY'])
+class SummarySignature < DSPy::Signature
+  description "Create summary focusing on specific topic"
+  
+  input do
+    const :content, String,
+      description: 'Original text content'
+    const :topic, String,
+      description: 'Topic to focus on'
+  end
+  
+  output do
+    const :summary, String,
+      description: 'Topic-focused summary'
+  end
 end
 
-# Initialize ReAct agent with the signature and tool
-calculator = CalculatorTool.new
-react_agent = DSPy::ReAct.new(MathQA, tools: [calculator])
-
-# Ask the question
-question_text = "What is 5 plus 7?"
-result = react_agent.forward(question: question_text)
-
-puts "Question: #{question_text}"
-puts "Answer: #{result.answer}"
-puts "Iterations: #{result.iterations}"
-puts "History:"
-result.history.each do |entry|
-  puts "  Step #{entry[:step]}:"
-  puts "    Thought: #{entry[:thought]}"
-  puts "    Action: #{entry[:action]}"
-  puts "    Action Input: #{entry[:action_input]}"
-  puts "    Observation: #{entry[:observation]}" if entry[:observation]
+class ArticlePipeline < DSPy::Signature
+  extend T::Sig
+  
+  def initialize
+    @topic_extractor = DSPy::Predict.new(TopicSignature)
+    @summarizer = DSPy::ChainOfThought.new(SummarySignature)
+  end
+  
+  sig { params(content: String).returns(T.untyped) }
+  def forward(content:)
+    # Extract topic
+    topic_result = @topic_extractor.call(content: content)
+    
+    # Create focused summary
+    summary_result = @summarizer.call(
+      content: content,
+      topic: topic_result.topic
+    )
+    
+    {
+      topic: topic_result.topic,
+      summary: summary_result.summary,
+      reasoning: summary_result.reasoning
+    }
+  end
 end
-# Expected output (will vary based on LLM's reasoning):
-# Question: What is 5 plus 7?
-# Answer: 12
-# Iterations: 2 
-# History:
-#   Step 1:
-#     Thought: I need to calculate 5 plus 7. I have a calculator tool that can do this.
-#     Action: calculator
-#     Action Input: 5 + 7
-#     Observation: 12
-#   Step 2:
-#     Thought: The calculator returned 12, which is the answer to "5 plus 7?". I can now finish.
-#     Action: finish
-#     Action Input: 12
-```
-
-**Example 2: Web Search with Serper.dev**
 
-For questions requiring up-to-date information or broader knowledge, the ReAct agent can use a web search tool. Here's an example using the `serper.dev` API.
+# Usage
+pipeline = ArticlePipeline.new
+result = pipeline.call(content: "Long article content...")
+```
 
-*Note: You'll need a Serper API key, which you can set in the `SERPER_API_KEY` environment variable.* 
+### Retrieval Augmented Generation
 
 ```ruby
-require 'net/http'
-require 'json'
-require 'uri'
-
-# Define a signature for web-based QA
-class WebQuestionAnswer < DSPy::Signature
-  description "Answers questions that may require web searches."
-
+class ContextualQA < DSPy::Signature
+  description "Answer questions using relevant context"
+  
   input do
-    required(:question).value(:string).meta(description: 'The question to answer, potentially requiring a web search.')
+    const :question, String,
+      description: 'The question to answer'
+    const :context, T::Array[String],
+      description: 'Relevant context passages'
   end
 
   output do
-    required(:answer).value(:string).meta(description: 'The final answer to the question.')
+    const :answer, String,
+      description: 'Answer based on the provided context'
+    const :confidence, Float,
+      description: 'Confidence in the answer (0.0 to 1.0)'
   end
 end
 
-# Define the Serper Search Tool
-class SerperSearchTool < DSPy::Tools::Tool
-  def initialize
-    super('web_search', 'Searches the web for a given query and returns the first organic result snippet. Useful for finding current information or answers to general knowledge questions.')
-  end
+# Usage with retriever
+retriever = YourRetrieverClass.new
+qa = DSPy::ChainOfThought.new(ContextualQA)
 
-  def call(query)
-    api_key = ENV['SERPER_API_KEY']
-    unless api_key
-      return "Error: SERPER_API_KEY environment variable not set."
-    end
+question = "What is the capital of France?"
+context = retriever.retrieve(question)  # Returns array of strings
 
-    uri = URI.parse("https://google.serper.dev/search")
-    request = Net::HTTP::Post.new(uri)
-    request['X-API-KEY'] = api_key
-    request['Content-Type'] = 'application/json'
-    request.body = JSON.dump({ q: query })
-
-    begin
-      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
-        http.request(request)
-      end
-
-      if response.is_a?(Net::HTTPSuccess)
-        results = JSON.parse(response.body)
-        first_organic_result = results['organic']&.first
-        if first_organic_result && first_organic_result['snippet']
-          return "Source: #{first_organic_result['link']}\nSnippet: #{first_organic_result['snippet']}"
-        elsif first_organic_result && first_organic_result['title']
-          return "Source: #{first_organic_result['link']}\nTitle: #{first_organic_result['title']}"
-        else
-          return "No relevant snippet found in the first result."
-        end
-      else
-        return "Error: Serper API request failed with status #{response.code} - #{response.body}"
-      end
-    rescue StandardError => e
-      return "Error performing web search: #{e.message}"
-    end
-  end
-end
+result = qa.call(question: question, context: context)
+puts result.reasoning   # Step-by-step reasoning
+puts result.answer      # "Paris"
+puts result.confidence  # 0.95
+```
 
-# Configure DSPy (if not already done)
-DSPy.configure do |c|
-  c.lm = DSPy::LM.new('openai/gpt-4o-mini', api_key: ENV['OPENAI_API_KEY']) # Ensure your LM is configured
-end
+## Instrumentation & Observability
 
-# Initialize ReAct agent with the signature and search tool
-search_tool = SerperSearchTool.new
-web_qa_agent = DSPy::ReAct.new(WebQuestionAnswer, tools: [search_tool])
-
-# Ask a question requiring web search
-question_text = "What is the latest news about the Mars rover Perseverance?"
-result = web_qa_agent.forward(question: question_text)
-
-puts "Question: #{question_text}"
-puts "Answer: #{result.answer}"
-puts "Iterations: #{result.iterations}"
-puts "History (summary):"
-result.history.each_with_index do |entry, index|
-  puts "  Step #{entry[:step]}: Action: #{entry[:action]}, Input: #{entry[:action_input]&.slice(0, 50)}..."
-  # For brevity, not printing full thought/observation here.
+DSPy.rb includes built-in instrumentation that captures detailed events and 
+performance metrics from your LLM operations. Perfect for monitoring your 
+applications and integrating with observability tools.
+
+### Quick Setup
+
+Enable instrumentation to start capturing events:
+
+```ruby
+DSPy::Instrumentation.configure do |config|
+  config.enabled = true
 end
-# The answer and history will depend on the LLM's reasoning and live search results.
 ```
 
-## Roadmap
+### Available Events
+
+Subscribe to these events to monitor different aspects of your LLM operations:
+
+| Event Name | Triggered When | Key Payload Fields |
+|------------|----------------|-------------------|
+| `dspy.lm.request` | LLM API request lifecycle | `gen_ai_system`, `model`, `provider`, `duration_ms`, `status` |
+| `dspy.lm.tokens` | Token usage tracking | `tokens_input`, `tokens_output`, `tokens_total` |
+| `dspy.predict` | Prediction operations | `signature_class`, `input_size`, `duration_ms`, `status` |
+| `dspy.chain_of_thought` | CoT reasoning | `signature_class`, `model`, `duration_ms`, `status` |
+| `dspy.react` | Agent operations | `max_iterations`, `tools_used`, `duration_ms`, `status` |
+| `dspy.react.tool_call` | Tool execution | `tool_name`, `tool_input`, `tool_output`, `duration_ms` |
+
+### Event Payloads
+
+The instrumentation emits events with structured payloads you can process:
+
+```ruby
+# Example event payload for dspy.predict
+{
+  signature_class: "QuestionAnswering",
+  model: "gpt-4o-mini",
+  provider: "openai", 
+  input_size: 45,
+  duration_ms: 1234.56,
+  cpu_time_ms: 89.12,
+  status: "success",
+  timestamp: "2024-01-15T10:30:00Z"
+}
+
+# Example token usage payload
+{
+  tokens_input: 150,
+  tokens_output: 45,
+  tokens_total: 195,
+  gen_ai_system: "openai",
+  signature_class: "QuestionAnswering"
+}
+```
+
+Events are emitted via dry-monitor notifications, giving you flexibility to 
+process them however you need - logging, metrics, alerts, or custom monitoring.
 
-### First Release
-- [x] Signatures and Predict module
-- [x] RAG examples
-- [x] Multi-Stage Pipelines
-- [x] Validate inputs and outputs with JSON Schema
-- [x] thread-safe global config
-- [x] Convert responses from hashes to Dry Poros (currently tons of footguns with hashes :fire:)
-- [ ] Cover unhappy paths: validation errors 
-- [x] Implement ReAct module for reasoning and acting
-- [ ] Add OpenTelemetry instrumentation
-- [ ] Improve logging
-- [ ] Add streaming support (?)
-- [x] Ensure thread safety
-- [ ] Comprehensive initial documentation, LLM friendly.
+### Token Tracking
 
-#### Backburner
+Token usage is extracted from actual API responses (OpenAI and Anthropic only), 
+giving you precise cost tracking:
 
-- [ ] Support for multiple LM providers (Anthropic, etc.)
-- [ ] Support for reasoning providers
-- [ ] Adaptive Graph of Thoughts with Tools
+```ruby
+# Token events include:
+{
+  tokens_input: 150,     # From API response
+  tokens_output: 45,     # From API response  
+  tokens_total: 195,     # From API response
+  gen_ai_system: "openai",
+  gen_ai_request_model: "gpt-4o-mini"
+}
+```
 
-### Optimizers
+### Configuration Options
 
-- [ ] Optimizing prompts: RAG
-- [ ] Optimizing prompts: Chain of Thought
-- [ ] Optimizing prompts: ReAct
-- [ ] Optimizing weights: Classification
+```ruby
+DSPy::Instrumentation.configure do |config|
+  config.enabled = true
+  config.log_to_stdout = false
+  config.log_file = 'log/dspy.log'
+  config.log_level = :info
+  
+  # Custom payload enrichment
+  config.custom_options = lambda do |event|
+    {
+      timestamp: Time.current.iso8601,
+      hostname: Socket.gethostname,
+      request_id: Thread.current[:request_id]
+    }
+  end
+end
+```
+
+### Integration with Monitoring Tools
+
+Subscribe to events for custom processing:
 
-## Contributing
+```ruby
+# Subscribe to all LM events
+DSPy::Instrumentation.subscribe('dspy.lm.*') do |event|
+  puts "#{event.id}: #{event.payload[:duration_ms]}ms"
+end
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+# Subscribe to specific events
+DSPy::Instrumentation.subscribe('dspy.predict') do |event|
+  MyMetrics.histogram('dspy.predict.duration', event.payload[:duration_ms])
+end
+```
 
 ## License
 
-`dspy.rb` is released under the [MIT License](LICENSE).
+This project is licensed under the MIT License.