smart_agent 0.1.8 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c371ec0662e5067d9f59514370fc1862e363828df6aff1a5b4ccf227884c8e7
-  data.tar.gz: ec952a5a0ba0ebd05ee7c011b563ba655426c5b19c3fa4d266c38acc4cecfa16
+  metadata.gz: 1b00ab32278897761aac333a1d4fd62a3bcec66dcd6768cb9cf4ff37f0de73d0
+  data.tar.gz: 6910abf5ce56fbb8b2b3016bc9f3556468ecc8aa0af338f44594bf82bd797149
 SHA512:
-  metadata.gz: ec27bb4178aaf04811763e68ae453c664b498d2b02c3bb919d832825d43bb127a3622d2045b4de3946c445aa75e7516719c91db0d98b27cb676533018392dd60
-  data.tar.gz: 6830fb847db1a225614c260da2f5624eecc8d5b47afe631519876265d642a2746237820fe9b4b3dd47361c1ed81a9472c8ce117f270faeb4020dc0831088afaa
+  metadata.gz: 33e2f4a134b67630803dd4753f827d16e1afe1ddde7807e8b9856ec5f8845978cae5de6fec5e4df37b95343e7831fbd018cf359e6b1f0ca77ecbc972d4b9ae02
+  data.tar.gz: 05b6424061a1a74050b6ca7e71ff79c45e2f0ec230fee83663ca6b802a53be71a2b4f37f21e59457ecfcdcc940d44d75bccd09cb9f91b02f971a204ea1c14326

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
@@ -144,7 +118,6 @@ module SmartAgent
           @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
@@ -153,6 +126,7 @@ module SmartAgent
           @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)
+          @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

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/version.rb

@@ -1,3 +1,3 @@
 module SmartAgent
-  VERSION = "0.1.8"
+  VERSION = "0.2.0"
 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.0
 platform: ruby
 authors:
 - Zhuang Biaowei
@@ -71,7 +71,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Intelligent agent framework with DSL and MCP integration
 test_files: []