smart_agent 0.1.8 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c371ec0662e5067d9f59514370fc1862e363828df6aff1a5b4ccf227884c8e7
-  data.tar.gz: ec952a5a0ba0ebd05ee7c011b563ba655426c5b19c3fa4d266c38acc4cecfa16
+  metadata.gz: 92f316229977853df082c594f3dfe42677dcb1d92e6e0ffe7e8c12dbf09db3cd
+  data.tar.gz: 42890f035e21b320b205b62f9de845cd7d2d0f492c13967e9147f52822af4702
 SHA512:
-  metadata.gz: ec27bb4178aaf04811763e68ae453c664b498d2b02c3bb919d832825d43bb127a3622d2045b4de3946c445aa75e7516719c91db0d98b27cb676533018392dd60
-  data.tar.gz: 6830fb847db1a225614c260da2f5624eecc8d5b47afe631519876265d642a2746237820fe9b4b3dd47361c1ed81a9472c8ce117f270faeb4020dc0831088afaa
+  metadata.gz: 0a837125205d17f4b9c3c3a3417c014f718c406a874fbc88a7339d59ee2dee1d5fd01fd4eb13654a28349bbbda97f1acc71b8b03b7a3ef14f21afe5f1dbbdf11
+  data.tar.gz: e721b313294d3f149cf986e9d4a3140a83fb68368542b527f5c2205fc1ff850c3a4f8982f08185bb0ac28fe681b21e95c604b557d81f19cd7a4e87b7eccc9111

data/README.md

@@ -1,89 +1,303 @@
 # SmartAgent Framework
 
-SmartAgent is an intelligent agent framework developed in Ruby, supporting tool calling and natural language interaction.
+[![Ruby Version](https://img.shields.io/badge/Ruby-3.2%2B-red)](https://www.ruby-lang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](./LICENSE)
+[![Version](https://img.shields.io/badge/Version-0.1.8-green.svg)](./lib/smart_agent/version.rb)
 
-## Features
+**An intelligent agent framework for Ruby with MCP support, tool calling, and multi-LLM integration**
 
-- Supports defining smart agents (SmartAgent) and tools (Tool)
-- Built-in utility tools:
-  - Weather query (get_weather)
-  - Math calculations (get_sum)
-  - Code generation and execution (get_code)
-- Integrated with OpenDigger MCP service
-- Supports natural language interaction in both English and Chinese
-- Extensible tool system
+## 🚀 Overview
 
-## Installation
+SmartAgent is a powerful Ruby framework for building intelligent agents that can interact with various AI models, execute tools, and integrate with external services through the Model Context Protocol (MCP). It provides a declarative DSL for defining agents, tools, and workflows.
 
-Ensure you have Ruby (>= 2.7) and Bundler installed:
+## ✨ Key Features
 
-```bash
-gem install bundler
+### 🤖 **Intelligent Agent System**
+- **Agent Definition**: Create custom agents with specific behaviors and capabilities
+- **Event-Driven Architecture**: Handle reasoning, content, and tool call events with custom callbacks
+- **Multi-Agent Support**: Build and manage multiple specialized agents
+
+### 🔧 **Tool Integration**
+- **Built-in Tools**: Weather queries, web search, code generation, and mathematical calculations
+- **Custom Tools**: Easy-to-define tools with parameter validation and type checking
+- **Tool Groups**: Organize related tools for better management
+
+### 🌐 **MCP (Model Context Protocol) Support**
+- **Multiple MCP Servers**: Connect to various MCP-compatible services
+- **Protocol Types**: Support for both STDIO and SSE (Server-Sent Events) connections
+- **Service Integration**: OpenDigger, PostgreSQL, geographic services, and more
+
+### 🎯 **Multi-LLM Backend Support**
+- **Multiple Providers**: OpenAI, DeepSeek, SiliconFlow, Qwen, Ollama, and more
+- **Flexible Configuration**: Easy switching between different AI models
+- **Streaming Support**: Real-time response streaming with event callbacks
+
+### 📝 **Advanced Prompt System**
+- **Template Engine**: ERB-based templates for dynamic prompt generation
+- **Worker System**: Specialized workers for different AI tasks
+- **History Management**: Conversation context and memory management
+
+## 📦 Installation
+
+### Prerequisites
+- Ruby 3.2.0 or higher
+- Bundler gem manager
+
+### Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'smart_agent'
 ```
 
-Then run:
+And then execute:
+```bash
+$ bundle install
+```
 
+Or install it yourself as:
 ```bash
-bundle install
+$ gem install smart_agent
 ```
 
-Or install the gem directly:
+### Configuration
+1. **Configure LLM providers** in `config/llm_config.yml`:
+```yaml
+llms:
+  deepseek:
+    adapter: openai
+    url: https://api.deepseek.com
+    api_key: ENV["DEEPSEEK_API_KEY"]
+    default_model: deepseek-reasoner
+  # Add other providers...
+```
 
-```bash
-gem install smart_agent
+2. **Set up agent configuration** in `config/agent.yml`:
+```yaml
+logger_file: "./log/agent.log"
+engine_config: "./config/llm_config.yml"
+agent_path: "./agents"
+tools_path: "./agents/tools"
+mcp_path: "./agents/mcps"
 ```
 
-## Usage Examples
+## 🛠️ Usage
 
-### Basic Usage
+### Basic Agent Creation
 
 ```ruby
 require 'smart_agent'
 
-agent = SmartAgent.build_agent(:smart_bot, tools: [:get_code])
+# Initialize the engine
+engine = SmartAgent::Engine.new("./config/agent.yml")
+
+# Define a smart agent
+SmartAgent.define :smart_bot do
+  call_tool = true
+  while call_tool
+    result = call_worker(:smart_bot, params, with_tools: true, with_history: true)
+    if result.call_tools
+      call_tools(result)
+      params[:text] = "please continue"
+    else
+      call_tool = false
+    end
+  end
+  result.response
+end
+
+# Build and configure the agent
+agent = engine.build_agent(:smart_bot, 
+  tools: [:get_weather, :search, :get_code], 
+  mcp_servers: [:opendigger, :postgres]
+)
 
-# Weather query
-puts agent.please("What's the weather in Shanghai tomorrow?")
+# Add event handlers
+agent.on_reasoning do |reasoning_content|
+  print reasoning_content.dig("choices", 0, "delta", "reasoning_content")
+end
 
-# Math calculation
-puts agent.please("Calculate the sum of 130 and 51")
+agent.on_content do |content|
+  print content.dig("choices", 0, "delta", "content")
+end
 
-# Code generation and execution
-puts agent.please("Calculate the area of a triangle with base 132 and height 7.6 using a Ruby function")
+# Use the agent
+response = agent.please("What's the weather like in Shanghai tomorrow?")
+puts response
 ```
 
-### Custom Tools
+### Custom Tool Definition
 
 ```ruby
-SmartAgent::Tool.define :my_tool do
-  param_define :param1, "Parameter description", :string
-  param_define :param2, "Another parameter", :integer
+SmartAgent::Tool.define :custom_calculator do
+  desc "Perform mathematical calculations"
+  param_define :expression, "Mathematical expression to evaluate", :string
+  param_define :precision, "Number of decimal places", :integer
   
-  if input_params
-    # Tool logic
-    "Processing result"
+  tool_proc do
+    expression = input_params["expression"]
+    precision = input_params["precision"] || 2
+    
+    begin
+      result = eval(expression)
+      result.round(precision)
+    rescue => e
+      "Error: #{e.message}"
+    end
   end
 end
 ```
 
-## MCP Integration
-
-Supports getting GitHub project metrics via OpenDigger MCP service:
+### MCP Server Integration
 
 ```ruby
-
+# Define MCP servers
 SmartAgent::MCPClient.define :opendigger do
   type :stdio
-  command "node ~/open-digger-mcp-server/dist/index.js"
+  command "node /path/to/open-digger-mcp-server/dist/index.js"
+end
+
+SmartAgent::MCPClient.define :postgres do
+  type :stdio
+  command "node /path/to/postgres-mcp-server/dist/index.js postgres://user:pass@localhost/db"
+end
+
+SmartAgent::MCPClient.define :web_service do
+  type :sse
+  url "https://api.example.com/mcp/sse"
+end
+
+# Use with agent
+agent = engine.build_agent(:research_bot, mcp_servers: [:opendigger, :postgres])
+```
+
+### Advanced Features
+
+#### Stream Processing with Events
+```ruby
+agent.on_reasoning do |chunk|
+  # Handle reasoning content in real-time
+  print chunk.dig("choices", 0, "delta", "reasoning_content")
 end
 
-puts agent.please("Query OpenRank metrics changes for Vue project on GitHub")
+agent.on_tool_call do |event|
+  case event[:status]
+  when :start
+    puts "🔧 Starting tool execution..."
+  when :end
+    puts "✅ Tool execution completed"
+  else
+    print event[:content] if event[:content]
+  end
+end
+```
+
+#### Custom Workers
+```ruby
+SmartPrompt.define_worker :code_analyzer do
+  use "deepseek"
+  model "deepseek-chat"
+  sys_msg "You are an expert code analyzer."
+  
+  prompt :analyze_template, {
+    code: params[:code],
+    language: params[:language]
+  }
+  
+  send_msg
+end
+```
+
+## 🏗️ Architecture
+
+### Core Components
+
+1. **SmartAgent::Engine**
+   - Configuration management
+   - Agent lifecycle management
+   - Tool and MCP server loading
+
+2. **SmartAgent::Agent**
+   - Agent behavior definition
+   - Tool calling coordination
+   - Event handling system
+
+3. **SmartAgent::Tool**
+   - Custom tool definition
+   - Parameter validation
+   - Function execution
+
+4. **SmartAgent::MCPClient**
+   - MCP protocol implementation
+   - External service integration
+   - Multi-protocol support (STDIO/SSE)
+
+5. **SmartAgent::Result**
+   - Response processing
+   - Tool call detection
+   - Content extraction
+
+### Directory Structure
 ```
+├── lib/smart_agent/          # Core framework code
+├── config/                   # Configuration files
+├── templates/                # Prompt templates
+├── workers/                  # Specialized AI workers
+├── agents/                   # Agent definitions (auto-loaded)
+├── agents/tools/             # Custom tools (auto-loaded)
+└── agents/mcps/              # MCP server definitions (auto-loaded)
+```
+
+## 🔧 Configuration
+
+### Supported LLM Providers
+- **OpenAI Compatible**: DeepSeek, SiliconFlow, Gitee AI
+- **Local Solutions**: Ollama, llama.cpp
+- **Cloud Services**: Alibaba Cloud DashScope
+
+### Environment Variables
+```bash
+export DEEPSEEK_API_KEY="your_deepseek_key"
+export OPENAI_API_KEY="your_openai_key"
+export SERPER_API_KEY="your_serper_key"  # For web search
+```
+
+## 🎯 Use Cases
+
+- **Research Assistants**: Integrate with academic databases and search engines
+- **Code Analysis Tools**: Generate, analyze, and execute code dynamically
+- **Data Analytics**: Connect to databases and perform complex queries
+- **Content Creation**: Multi-modal content generation with tool assistance
+- **API Integration**: Bridge different services through MCP protocol
+
+## 🤝 Contributing
+
+We welcome contributions! Please:
+
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new functionality
+4. Ensure all tests pass
+5. Submit a pull request
+
+### Development Setup
+```bash
+git clone https://github.com/zhuangbiaowei/smart_agent.git
+cd smart_agent
+bundle install
+ruby test.rb  # Run example tests
+```
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
-## Contributing
+## 🙏 Acknowledgments
 
-Issues and pull requests are welcome.
+- Built on top of the SmartPrompt framework
+- Supports the Model Context Protocol (MCP)
+- Integrates with various AI model providers
 
-## License
+---
 
-MIT License. See LICENSE file for details.
+**⭐ Star this repository if you find it useful!**

data/lib/smart_agent/agent.rb

@@ -10,6 +10,10 @@ module SmartAgent
       @code = self.class.agents[name]
     end
 
+    def name
+      @name
+    end
+
     def on_reasoning(&block)
       @reasoning_event_proc = block
     end
@@ -66,7 +70,8 @@ module SmartAgent
     end
 
     def call_worker(name, params, with_tools: true, with_history: false)
-      SmartAgent.logger.info ("Call Worker name is: #{name}")
+      SmartAgent.logger.info("Call Worker name is: #{name}")
+      SmartAgent.logger.info("Call Worker params is: #{params}")
       if with_tools
         simple_tools = []
         if @agent.tools
@@ -85,46 +90,15 @@ module SmartAgent
       params[:with_history] = with_history
       ret = nil
       if @agent.on_event
-        full_result = {}
-        tool_calls = []
-        result = SmartAgent.prompt_engine.call_worker_by_stream(name, params) do |chunk, _bytesize|
-          if full_result.empty?
-            full_result["id"] = chunk["id"]
-            full_result["object"] = chunk["object"]
-            full_result["created"] = chunk["created"]
-            full_result["model"] = chunk["model"]
-            full_result["choices"] = [{
-              "index" => 0,
-              "message" => {
-                "role" => "assistant",
-                "content" => "",
-                "reasoning_content" => "",
-                "tool_calls" => [],
-              },
-            }]
-            full_result["usage"] = chunk["usage"]
-            full_result["system_fingerprint"] = chunk["system_fingerprint"]
-          end
+        SmartAgent.prompt_engine.call_worker_by_stream(name, params) do |chunk, _bytesize|
           if chunk.dig("choices", 0, "delta", "reasoning_content")
-            full_result["choices"][0]["message"]["reasoning_content"] += chunk.dig("choices", 0, "delta", "reasoning_content")
             @agent.processor(:reasoning).call(chunk) if @agent.processor(:reasoning)
           end
           if chunk.dig("choices", 0, "delta", "content")
-            full_result["choices"][0]["message"]["content"] += chunk.dig("choices", 0, "delta", "content")
             @agent.processor(:content).call(chunk) if @agent.processor(:content)
           end
-          if chunk_tool_calls = chunk.dig("choices", 0, "delta", "tool_calls")
-            chunk_tool_calls.each do |tool_call|
-              if tool_calls.size > tool_call["index"]
-                tool_calls[tool_call["index"]]["function"]["arguments"] += tool_call["function"]["arguments"]
-              else
-                tool_calls << tool_call
-              end
-            end
-          end
         end
-        full_result["choices"][0]["message"]["tool_calls"] = tool_calls
-        result = full_result
+        result = SmartAgent.prompt_engine.stream_response
       else
         result = SmartAgent.prompt_engine.call_worker(name, params)
       end
@@ -132,6 +106,42 @@ module SmartAgent
       return ret
     end
 
+    def safe_parse(input)
+      # 保存原始输入用于调试
+      original_input = input.dup
+
+      # 步骤1: 清理输入
+      cleaned = input.strip
+
+      # 步骤2: 处理外层引号（如果存在）
+      if cleaned.start_with?('"') && cleaned.end_with?('"')
+        cleaned = cleaned[1...-1]
+      end
+
+      # 步骤3: 反转义双重转义字符
+      # 关键：只处理需要反转义的字符，保持JSON合法性
+      cleaned = cleaned
+        .gsub(/\\"/, '"') # 反转义引号
+        .gsub(/\\\\/, '\\')    # 反转义反斜杠
+      # 不反转义\n, \t, \r等，因为它们是JSON合法的转义序列
+
+      # 步骤4: 尝试解析
+      begin
+        return JSON.parse(cleaned)
+      rescue JSON::ParserError => e
+        # 如果清理后失败，尝试原始输入
+        begin
+          return JSON.parse(original_input)
+        rescue JSON::ParserError
+          puts "Failed to parse JSON: #{e.message}"
+          puts "Original: #{original_input}"
+          puts "Cleaned: #{cleaned}"
+          # 返回原始字符串以便后续处理
+          return original_input
+        end
+      end
+    end
+
     def call_tools(result)
       @agent.processor(:tool).call({ :status => :start }) if @agent.processor(:tool)
       SmartAgent.logger.info("call tools: " + result.to_s)
@@ -139,23 +149,27 @@ module SmartAgent
       result.call_tools.each do |tool|
         tool_call_id = tool["id"]
         tool_name = tool["function"]["name"].to_sym
-        params = JSON.parse(tool["function"]["arguments"])
+        params = safe_parse(tool["function"]["arguments"])
         if Tool.find_tool(tool_name)
           @agent.processor(:tool).call({ :content => "ToolName is `#{tool_name}`\n" }) if @agent.processor(:tool)
           @agent.processor(:tool).call({ :content => "params is `#{params}`\n" }) if @agent.processor(:tool)
           tool_result = Tool.find_tool(tool_name).call(params)
-
-          SmartAgent.prompt_engine.history_messages << { "role" => "assistant", "content" => "", "tool_calls" => [tool] } #result.response.dig("choices", 0, "message")
-          SmartAgent.prompt_engine.history_messages << { "role" => "tool", "tool_call_id" => tool_call_id, "content" => tool_result.to_s.force_encoding("UTF-8") }
-          results << tool_result
+          if tool_result
+            SmartAgent.prompt_engine.history_messages << { "role" => "assistant", "content" => "", "tool_calls" => [tool] } #result.response.dig("choices", 0, "message")
+            SmartAgent.prompt_engine.history_messages << { "role" => "tool", "tool_call_id" => tool_call_id, "content" => tool_result.to_s.force_encoding("UTF-8") }
+            results << tool_result
+          end
         end
         if server_name = MCPClient.find_server_by_tool_name(tool_name)
           @agent.processor(:tool).call({ :content => "MCP Server is `#{server_name}`, ToolName is `#{tool_name}`\n" }) if @agent.processor(:tool)
           @agent.processor(:tool).call({ :content => "params is `#{params}`\n" }) if @agent.processor(:tool)
           tool_result = MCPClient.new(server_name).call(tool_name, params)
-          SmartAgent.prompt_engine.history_messages << { "role" => "assistant", "content" => "", "tool_calls" => [tool] } # result.response.dig("choices", 0, "message")
-          SmartAgent.prompt_engine.history_messages << { "role" => "tool", "tool_call_id" => tool_call_id, "content" => tool_result.to_s }
-          results << tool_result
+          if tool_result
+            @agent.processor(:tool).call({ :content => tool_result })
+            SmartAgent.prompt_engine.history_messages << { "role" => "assistant", "content" => "", "tool_calls" => [tool] } # result.response.dig("choices", 0, "message")
+            SmartAgent.prompt_engine.history_messages << { "role" => "tool", "tool_call_id" => tool_call_id, "content" => tool_result.to_s }
+            results << tool_result
+          end
         end
         @agent.processor(:tool).call({ :content => " ... done\n" }) if @agent.processor(:tool)
       end

data/lib/smart_agent/mcp_client.rb

@@ -4,19 +4,19 @@ module SmartAgent
       SmartAgent.logger.info "Create mcp server's name is #{name}"
       @name = name
       @code = self.class.servers[name]
-    end
-
-    def to_json
       @context = MCPContext.new
       @context.instance_eval(&@code)
       command_path = @context.command_path
       if @context.mcp_type == :stdio
-        client = MCP::StdioClient.new(command_path)
+        @client = MCP::StdioClient.new(command_path)
       else
-        client = MCP::SSEClient.new(command_path)
+        @client = MCP::SSEClient.new(command_path)
       end
-      client.start
-      mcp_server_json = client.list_tools
+      @client.start
+    end
+
+    def to_json
+      mcp_server_json = @client.list_tools
       if mcp_server_json
         mcp_server_json["tools"].each do |tool|
           MCPClient.set_server(tool["name"].to_sym, @name)
@@ -26,16 +26,7 @@ module SmartAgent
     end
 
     def call(tool_name, params)
-      @context = MCPContext.new
-      @context.instance_eval(&@code)
-      command_path = @context.command_path
-      if @context.mcp_type == :stdio
-        client = MCP::StdioClient.new(command_path)
-      else
-        client = MCP::SSEClient.new(command_path)
-      end
-      client.start
-      client.call_method(
+      @client.call_method(
         {
           "name": tool_name.to_s,
           "arguments": params,
@@ -43,6 +34,10 @@ module SmartAgent
       )
     end
 
+    def close
+      @client.stop
+    end
+
     class << self
       def servers
         @servers ||= {}
@@ -54,6 +49,8 @@ module SmartAgent
 
       def define(name, &block)
         servers[name] = block
+        client = MCPClient.new(name)
+        client.to_json
       end
 
       def set_server(tool_name, server_name)

data/lib/smart_agent/result.rb

@@ -1,7 +1,7 @@
 module SmartAgent
   class Result
     def initialize(response)
-      SmartAgent.logger.info("response is:" + response.to_s)
+      #SmartAgent.logger.info("response is:" + response.to_s)
       @response = response
     end
 
@@ -10,10 +10,14 @@ module SmartAgent
         return false
       else
         tool_calls = @response.dig("choices", 0, "message", "tool_calls")
-        if tool_calls.empty?
-          return false
+        if tool_calls
+          unless tool_calls.empty?
+            return tool_calls
+          else
+            return false
+          end            
         else
-          return tool_calls
+          return false
         end
       end
     end

data/lib/smart_agent/tool.rb

@@ -90,6 +90,15 @@ module SmartAgent
       SmartAgent.prompt_engine.call_worker(name, params)
     end
 
+    def call_tool(name, params)
+      if Tool.find_tool(name)
+        return Tool.find_tool(name).call(params)
+      end
+      if server_name = MCPClient.find_server_by_tool_name(name)
+        return MCPClient.new(server_name).call(name, params)
+      end
+    end
+
     def tool_proc(&block)
       @proc = block
     end

data/lib/smart_agent/version.rb

@@ -1,3 +1,3 @@
 module SmartAgent
-  VERSION = "0.1.8"
+  VERSION = "0.2.1"
 end

data/lib/smart_agent.rb

@@ -1,4 +1,4 @@
-require "../mcp-sdk.rb/lib/mcp"
+require "mcp"
 
 require File.expand_path("../smart_agent/version", __FILE__)
 require File.expand_path("../smart_agent/engine", __FILE__)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smart_agent
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.1
 platform: ruby
 authors:
 - Zhuang Biaowei
@@ -23,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mcp-sdk.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -71,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.7.1
 specification_version: 4
 summary: Intelligent agent framework with DSL and MCP integration
 test_files: []