ai-agents-datacircle 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml ADDED
@@ -0,0 +1,7 @@
1
+ ---
2
+ SHA256:
3
+ metadata.gz: f52b716da8ade11c06861bf22d5eb585f987765ac9ef0a42f1acb9870c64198f
4
+ data.tar.gz: 3f9a1bd50fb0a9969ef6b8570d88b1f21f4c90468b69ac442bf1b6d5abc7f900
5
+ SHA512:
6
+ metadata.gz: 7a0bcc8edde4b0b9a7f4e686c5601b01f9f255acd1837d15440ec28bd9837ab833d7574b50f6dd3ae7e55b200b5c32b02e343cb1090e5cbc98d919b88ec84b5d
7
+ data.tar.gz: 6e0204eb9f17578346ee5f344918d2a5c1103e7986c6dbd7d1829d41fd635afd9825aa474bf4ab748320d6ba618ba12075816e923fe7c600cc0703e11f885011
data/LICENSE.txt ADDED
@@ -0,0 +1,21 @@
1
+ MIT License
2
+
3
+ Copyright (c) 2026 Datacircle
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
+ SOFTWARE.
data/README.md ADDED
@@ -0,0 +1,78 @@
1
+ # Datacircle tools for ai-agents
2
+
3
+ Find the best GTM APIs. We benchmark all the GTM APIs and we put the results on our website.
4
+
5
+ Our website: https://datacircle.dev
6
+
7
+ This gem gives the agents of [ai-agents](https://github.com/chatwoot/ai-agents) four tools that call Datacircle's open API, https://api.datacircle.dev/v1. You need no key and no account.
8
+
9
+ | Tool | What the tool gives | Call |
10
+ | --- | --- | --- |
11
+ | `datacircle_list_apis` | Every GTM API on Datacircle, with the API's slug, number of plans, number of providers and best plan | `GET /apis` |
12
+ | `datacircle_best_plans` | One API's plans, sorted by score out of 100, best first. Each plan comes with a rank and a price per 1,000 calls | `GET /apis/{slug}/best` |
13
+ | `datacircle_search_plans` | Plans that match a provider or plan name, on all APIs or on one API. You can sort them by score, provider or price | `GET /plans` |
14
+ | `datacircle_provider` | The APIs a provider sells, and the provider's rank on each API | `GET /providers/{slug}` |
15
+
16
+ ## Install
17
+
18
+ ```bash
19
+ bundle add ai-agents-datacircle
20
+ ```
21
+
22
+ The gem needs `ai-agents` 0.13.0 or later and Ruby 3.2 or later.
23
+
24
+ ## Use the tools
25
+
26
+ Give the tools to an agent:
27
+
28
+ ```ruby
29
+ require "agents"
30
+ require "agents/datacircle"
31
+
32
+ Agents.configure do |config|
33
+ config.openai_api_key = ENV["OPENAI_API_KEY"]
34
+ end
35
+
36
+ agent = Agents::Agent.new(
37
+ name: "GTM API Expert",
38
+ instructions: "Help people choose a GTM API.",
39
+ tools: Agents::Datacircle.tools
40
+ )
41
+
42
+ result = Agents::Runner.with_agents(agent).run("Who are the 3 best providers for the email-finder API?")
43
+ puts result.output
44
+ ```
45
+
46
+ You can list our tools beside your own: `tools: [*Agents::Datacircle.tools, MyTool.new]`. To give the agent only some of our tools, list each one by class: `tools: [Agents::Datacircle::BestPlans.new]`. The tools also work in handoffs and in `agent.as_tool`.
47
+
48
+ ## Make each call yourself
49
+
50
+ You can call a tool without a model and read the JSON answer:
51
+
52
+ ```ruby
53
+ Agents::Datacircle::BestPlans.new.perform(slug: "email-finder", limit: 3)
54
+ # => "{\"api\":\"Employee email\",\"slug\":\"email-finder\",...,\"plans\":[{\"api\":\"Employee email\",\"rank\":1,\"provider\":\"Emelia\",...}]}"
55
+ ```
56
+
57
+ `Agents::Datacircle::Calls.new` makes the same calls and gives you a Hash. The methods of `Calls` are `list_apis`, `best_plans`, `search_plans` and `provider`.
58
+
59
+ ## What the model reads
60
+
61
+ Each tool gives the model a JSON object as text. Each plan comes with a rank, provider, plan, score, price per 1,000 (`perThousand`, in dollars) and a page on datacircle.dev. That page lists every field.
62
+
63
+ The tool gives `{"error": "..."}` with the API's message when the API has no data. An unknown slug is one case. The tool also gives `{"error": "..."}` when the API can't be reached. The tool never raises. Your agent keeps running, and the model can call the tool again.
64
+
65
+ `Agents::Datacircle.tools(base_url: ...)` sets a new address for the tools, for example your own proxy. Leave `base_url` out and the tools call https://api.datacircle.dev/v1.
66
+
67
+ ## Network
68
+
69
+ Each tool call makes one HTTPS GET request to https://api.datacircle.dev/v1. A tool makes two requests when the model gives a name instead of a slug. A tool also makes two requests when the model gives a provider instead of an API. A request holds the tool's own arguments and nothing else: no key and nothing from your chats. The API takes up to 60 calls a minute from one IP address. A tool waits once, for a minute at most, when the API asks for a wait. The gem depends only on `ai-agents` and stores nothing.
70
+
71
+ ## Links
72
+
73
+ - Datacircle: https://datacircle.dev
74
+ - The API: https://datacircle.dev/api
75
+ - The API's spec: https://api.datacircle.dev/v1/openapi.json
76
+ - What each key means: https://datacircle.dev/fields
77
+
78
+ MIT license.
@@ -0,0 +1,147 @@
1
+ # frozen_string_literal: true
2
+
3
+ module Agents
4
+ module Datacircle
5
+ # A plan holds about 90 keys (its terms of use, its aggregators...): these choose a plan, the rest is on its page.
6
+ PLAN_KEYS = %w[api rank provider plan score perThousand notFoundPerThousand billing pay currency units unit
7
+ strengths latencyMs page pricingPage docs].freeze
8
+
9
+ # Where a provider's plans are, for a model that sent a provider's name to an API's tool.
10
+ FOR_PROVIDER = "A provider's plans: datacircle_search_plans with its name as query, like bright data, " \
11
+ 'or datacircle_provider.'
12
+
13
+ PRICE = "perThousand is a plan's price of 1,000 items in dollars, pay the plan's whole price in its currency."
14
+
15
+ # The four calls of https://api.datacircle.dev/v1 behind the tools, each answering a Hash: {"error" => ...} for an
16
+ # input the API can't take, and Error raised when the API gives no data. A tool answers both as {"error" => ...}
17
+ # for the model to read and call again.
18
+ class Calls
19
+ def initialize(base_url: Client::BASE)
20
+ @client = Client.new(base_url: base_url)
21
+ end
22
+
23
+ # GET /apis, the APIs whose name or slug holds the most of the query's words first.
24
+ def list_apis(query: nil, limit: nil)
25
+ apis = @client.get('/apis')
26
+ words = query.to_s.downcase.tr('-', ' ').split
27
+ held = apis.each_with_index.filter_map do |api, index|
28
+ name = "#{api['api']} #{api['slug'].to_s.tr('-', ' ')}".downcase
29
+ matched = words.count { |word| name.include?(word) }
30
+ [-matched, index, api] if matched.positive? || words.empty?
31
+ end.sort_by { |matched, index, _| [matched, index] }
32
+ note = nil
33
+ if words.any? && (held.empty? || -held.first.first < words.size)
34
+ # A provider's name sent as an API's, like Bright Data, or a question: where its plans are, and the sheet's
35
+ # order when no API holds a word of it.
36
+ note = "No API's name holds every word of #{query.to_s.strip.inspect}. #{FOR_PROVIDER}"
37
+ if held.empty?
38
+ held = apis.each_with_index.map { |api, index| [0, index, api] }
39
+ note += " These are the sheet's APIs in its order."
40
+ end
41
+ end
42
+ found = { 'total' => held.size,
43
+ 'apis' => held.first(number(limit, 1, 200) || 20).map { |_, _, api| brief(api, %w[api slug plans providers best bestPage sheetPage]) } }
44
+ note ? { 'note' => note }.merge(found) : found
45
+ end
46
+
47
+ # GET /apis/{slug}/best
48
+ def best_plans(slug: nil, limit: nil)
49
+ api = slugify(slug)
50
+ return { 'error' => "Give an API's slug, like email-finder: datacircle_list_apis gives every slug. #{FOR_PROVIDER}" } if api.empty?
51
+
52
+ begin
53
+ found = @client.get("/apis/#{api}/best", limit: number(limit, 1, 50))
54
+ rescue Error => e
55
+ raise unless e.status == 404
56
+
57
+ # An API's name sent as its slug, like Employee email: the API of that name.
58
+ named = @client.get('/apis').find { |entry| slugify(entry['api']) == api }
59
+ # A provider's name sent as the API's slug: the API's words, and where a provider's plans are.
60
+ return { 'error' => "#{e.message}. datacircle_list_apis gives every API's slug. #{FOR_PROVIDER}" } unless named
61
+
62
+ found = @client.get("/apis/#{named['slug']}/best", limit: number(limit, 1, 50))
63
+ end
64
+ found.merge('plans' => Array(found['plans']).map { |plan| brief(plan) })
65
+ end
66
+
67
+ # GET /plans
68
+ def search_plans(query: nil, api: nil, sort: nil, limit: nil, offset: nil)
69
+ notes = []
70
+ begin
71
+ found = search(api, query, sort, limit, offset)
72
+ rescue Error => e
73
+ raise unless e.status == 400 && e.message.include?('api must be') && query.to_s.strip.empty?
74
+
75
+ # A provider's name sent as the API: the plans whose provider or plan name holds it.
76
+ api, query = nil, api
77
+ found = search(api, query, sort, limit, offset)
78
+ notes << "No API is named #{query.to_s.strip.inspect}: these are the plans whose provider or plan name holds it."
79
+ end
80
+ if found['total'].to_i.zero? && query.to_s.include?('-')
81
+ # A slug sent as a name, like bright-data, which no name holds: its words, like bright data. A name with a
82
+ # hyphen, like A-Leads, is found as it is first.
83
+ words = query.to_s.tr('-', ' ').split.join(' ')
84
+ found = search(api, words, sort, limit, offset)
85
+ notes << "No provider's or plan's name holds #{query.to_s.strip.inspect}: these are the plans whose name holds #{words.inspect}."
86
+ end
87
+ found = found.merge('plans' => Array(found['plans']).map { |plan| brief(plan) })
88
+ notes.empty? ? found : { 'note' => notes.join(' ') }.merge(found)
89
+ end
90
+
91
+ # GET /providers/{slug}
92
+ def provider(slug: nil)
93
+ name = slugify(slug)
94
+ return { 'error' => "Give a provider's slug or name, like bright-data or Bright Data" } if name.empty?
95
+
96
+ begin
97
+ found = @client.get("/providers/#{name}")
98
+ rescue Error => e
99
+ raise unless e.status == 404
100
+
101
+ return { 'error' => "#{e.message.split(':').first}. A provider's plans by its name: datacircle_search_plans with " \
102
+ 'words of its name as query, like bright data.' }
103
+ end
104
+ apis = Array(found['apis']).map do |entry|
105
+ plans = Array(entry['plans'])
106
+ brief(entry, %w[api slug rank bestPage]).merge('plans' => plans.size, 'best' => best(plans)).compact
107
+ end
108
+ # Its best rank first, the APIs where it has none last, in the API's order.
109
+ apis = apis.each_with_index.sort_by { |entry, index| [entry['rank'].is_a?(Numeric) ? entry['rank'] : Float::INFINITY, index] }.map(&:first)
110
+ found.merge('apis' => apis, 'total' => apis.size, 'ranked' => apis.count { |entry| entry['rank'].is_a?(Numeric) })
111
+ end
112
+
113
+ private
114
+
115
+ def search(api, query, sort, limit, offset)
116
+ @client.get('/plans', api: api.to_s.strip, query: query.to_s.strip,
117
+ sort: (sort.to_s if %w[score provider price].include?(sort.to_s)),
118
+ limit: number(limit, 1, 50), offset: number(offset, 0, 1_000_000))
119
+ end
120
+
121
+ def brief(item, keys = PLAN_KEYS)
122
+ keys.each_with_object({}) { |key, kept| kept[key] = item[key] unless item[key].nil? }
123
+ end
124
+
125
+ # A number the model sent, within the API's range, or nil when it sent none.
126
+ def number(value, low, high)
127
+ return nil if value.nil? || value.to_s.strip.empty?
128
+ return value.to_i.clamp(low, high) if value.is_a?(Numeric)
129
+
130
+ Integer(value.to_s.strip, 10).clamp(low, high)
131
+ rescue ArgumentError
132
+ nil
133
+ end
134
+
135
+ # The API's rule for a slug: the name in lowercase letters and digits, the rest a hyphen.
136
+ def slugify(value)
137
+ value.to_s.strip.downcase.unicode_normalize(:nfkd).gsub(/\p{Mn}/, '').gsub(/[^a-z0-9]+/, '-').gsub(/\A-|-\z/, '')
138
+ end
139
+
140
+ # A provider's best plan on an API: its lowest rank, else its first.
141
+ def best(plans)
142
+ top = plans.select { |plan| plan['rank'].is_a?(Numeric) }.min_by { |plan| plan['rank'] } || plans.first
143
+ top && brief(top, %w[plan score perThousand page])
144
+ end
145
+ end
146
+ end
147
+ end
@@ -0,0 +1,76 @@
1
+ # frozen_string_literal: true
2
+
3
+ require 'json'
4
+ require 'net/http'
5
+ require 'uri'
6
+
7
+ module Agents
8
+ module Datacircle
9
+ # What Datacircle's API answered when it gave no data (its HTTP status in #status), or why it could not be reached.
10
+ class Error < StandardError
11
+ attr_reader :status
12
+
13
+ def initialize(message = nil, status: nil)
14
+ super(message)
15
+ @status = status
16
+ end
17
+ end
18
+
19
+ # One HTTPS GET to Datacircle's open API, with no key: its answer as a Hash or an Array.
20
+ class Client
21
+ BASE = 'https://api.datacircle.dev/v1'
22
+
23
+ def initialize(base_url: BASE)
24
+ @base = base_url.to_s.chomp('/')
25
+ end
26
+
27
+ def get(path, params = {})
28
+ uri = URI("#{@base}#{path}")
29
+ query = params.reject { |_, value| value.nil? || value.to_s.strip.empty? }
30
+ uri.query = URI.encode_www_form(query) unless query.empty?
31
+ 2.times do |attempt|
32
+ response = request(uri)
33
+ return parse(response) if response.is_a?(Net::HTTPSuccess)
34
+
35
+ if response.code == '429' && attempt.zero?
36
+ sleep(wait(response))
37
+ next
38
+ end
39
+ raise Error.new(words(response), status: response.code.to_i)
40
+ end
41
+ raise Error.new("Datacircle's API answered 429 twice: wait a minute and call again", status: 429)
42
+ end
43
+
44
+ private
45
+
46
+ def request(uri)
47
+ Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https', open_timeout: 15, read_timeout: 30) do |http|
48
+ http.get(uri.request_uri, 'Accept' => 'application/json', 'User-Agent' => "ai-agents-datacircle/#{VERSION}")
49
+ end
50
+ rescue SocketError, SystemCallError, IOError, Timeout::Error, OpenSSL::SSL::SSLError, Net::HTTPBadResponse => e
51
+ raise Error, "Datacircle's API could not be reached: #{e.message}"
52
+ end
53
+
54
+ def parse(response)
55
+ JSON.parse(response.body.to_s)
56
+ rescue JSON::ParserError
57
+ raise Error.new("Datacircle's API answered #{response.code} with no JSON", status: response.code.to_i)
58
+ end
59
+
60
+ # The API asks to wait in Retry-After: its seconds, a minute at most.
61
+ def wait(response)
62
+ Integer(response['Retry-After'] || 30).clamp(1, 60)
63
+ rescue ArgumentError
64
+ 30
65
+ end
66
+
67
+ # The API's own words: its error of a 4xx, else its status.
68
+ def words(response)
69
+ parsed = JSON.parse(response.body.to_s)
70
+ parsed.is_a?(Hash) && parsed['error'] ? parsed['error'].to_s : "Datacircle's API answered #{response.code}"
71
+ rescue JSON::ParserError
72
+ "Datacircle's API answered #{response.code}"
73
+ end
74
+ end
75
+ end
76
+ end
@@ -0,0 +1,134 @@
1
+ # frozen_string_literal: true
2
+
3
+ module Agents
4
+ module Datacircle
5
+ # A tool of Datacircle's open API for an Agents::Agent's tools:. Its instance keeps only where it calls, so one
6
+ # instance serves every run and thread, as ai-agents asks of a tool.
7
+ class Tool < Agents::Tool
8
+ # base_url: where the tool calls, https://api.datacircle.dev/v1 when left out.
9
+ def initialize(base_url: nil)
10
+ super()
11
+ @base_url = base_url || Client::BASE
12
+ end
13
+
14
+ # The call's answer as JSON text, as the runner calls it with the model's arguments. Keys the tool doesn't take
15
+ # are dropped, a number sent as text is read, one out of range is brought into it. When the API gives no data it
16
+ # answers {"error": ...} with the API's words, never raises: a raise would end the agent's run, the words let the
17
+ # model call again.
18
+ def perform(_tool_context = nil, **arguments)
19
+ given = arguments.to_h { |key, value| [key.to_sym, value] }
20
+ taken = method(:answer).parameters.map(&:last)
21
+ JSON.generate(answer(**given.slice(*taken).reject { |_, value| value.nil? }))
22
+ rescue Error => e
23
+ JSON.generate('error' => e.message)
24
+ end
25
+
26
+ private
27
+
28
+ def calls
29
+ Calls.new(base_url: @base_url)
30
+ end
31
+ end
32
+
33
+ # GET /apis
34
+ class ListApis < Tool
35
+ def self.tool_name = 'datacircle_list_apis'
36
+
37
+ description "Lists the GTM APIs on Datacircle's sheet (https://datacircle.dev), with each API's slug, how many " \
38
+ "plans and providers it has and its best plan. Call it first to find an API's slug."
39
+ parameters(
40
+ type: 'object',
41
+ properties: {
42
+ query: { type: 'string',
43
+ description: "Words of the API's name or slug, like email or linkedin profile: the APIs that hold " \
44
+ "the most of them come first. The sheet's order when left out." },
45
+ limit: { type: 'integer', minimum: 1, maximum: 200,
46
+ description: 'How many APIs to give, 1 to 200. 20 when left out: the sheet has about 150.' }
47
+ },
48
+ required: []
49
+ )
50
+
51
+ private
52
+
53
+ def answer(query: nil, limit: nil)
54
+ calls.list_apis(query: query, limit: limit)
55
+ end
56
+ end
57
+
58
+ # GET /apis/{slug}/best
59
+ class BestPlans < Tool
60
+ def self.tool_name = 'datacircle_best_plans'
61
+
62
+ description "Gives an API's plans best first by their score out of 100 on Datacircle's benchmark " \
63
+ '(https://datacircle.dev), each with its rank, provider, plan, $ per 1,000 calls and its page. ' \
64
+ "#{PRICE}"
65
+ parameters(
66
+ type: 'object',
67
+ properties: {
68
+ slug: { type: 'string',
69
+ description: "The API's slug, like email-finder or linkedin-profile, as datacircle_list_apis gives it." },
70
+ limit: { type: 'integer', minimum: 1, maximum: 50, description: 'How many plans to give, 1 to 50. 10 when left out.' }
71
+ },
72
+ required: ['slug']
73
+ )
74
+
75
+ private
76
+
77
+ def answer(slug: nil, limit: nil)
78
+ calls.best_plans(slug: slug, limit: limit)
79
+ end
80
+ end
81
+
82
+ # GET /plans
83
+ class SearchPlans < Tool
84
+ def self.tool_name = 'datacircle_search_plans'
85
+
86
+ description "Searches every plan on Datacircle's sheet (https://datacircle.dev), or one API's, by provider or plan " \
87
+ "name, sorted by score, provider or price. Gives how many were found and up to limit of them. #{PRICE}"
88
+ parameters(
89
+ type: 'object',
90
+ properties: {
91
+ query: { type: 'string', description: "Words that must all appear in the provider's or plan's name, like bright data." },
92
+ api: { type: 'string',
93
+ description: "Only this API's plans: its name or slug, like email-finder. A provider's name goes in " \
94
+ 'query, never here. Every API when left out.' },
95
+ sort: { type: 'string', enum: %w[score provider price],
96
+ description: 'score (best first, the default), provider (A to Z) or price ($ per 1,000, lowest first).' },
97
+ limit: { type: 'integer', minimum: 1, maximum: 50, description: 'How many plans to give, 1 to 50. 10 when left out.' },
98
+ offset: { type: 'integer', minimum: 0, description: 'How many found plans to skip first. 0 when left out.' }
99
+ },
100
+ required: []
101
+ )
102
+
103
+ private
104
+
105
+ def answer(query: nil, api: nil, sort: nil, limit: nil, offset: nil)
106
+ calls.search_plans(query: query, api: api, sort: sort, limit: limit, offset: offset)
107
+ end
108
+ end
109
+
110
+ # GET /providers/{slug}
111
+ class Provider < Tool
112
+ def self.tool_name = 'datacircle_provider'
113
+
114
+ description "Gives each API one provider sells and its rank on each on Datacircle's benchmark " \
115
+ '(https://datacircle.dev), with its best plan there, its best rank first. total is how many APIs it ' \
116
+ 'sells, ranked on how many of them it has a rank.'
117
+ parameters(
118
+ type: 'object',
119
+ properties: {
120
+ slug: { type: 'string',
121
+ description: "The provider's slug, like bright-data, or its name, like Bright Data: the name is made " \
122
+ 'a slug.' }
123
+ },
124
+ required: ['slug']
125
+ )
126
+
127
+ private
128
+
129
+ def answer(slug: nil)
130
+ calls.provider(slug: slug)
131
+ end
132
+ end
133
+ end
134
+ end
@@ -0,0 +1,7 @@
1
+ # frozen_string_literal: true
2
+
3
+ module Agents
4
+ module Datacircle
5
+ VERSION = '0.1.0'
6
+ end
7
+ end
@@ -0,0 +1,26 @@
1
+ # frozen_string_literal: true
2
+
3
+ require 'json'
4
+ require 'agents'
5
+ require_relative 'datacircle/version'
6
+ require_relative 'datacircle/client'
7
+ require_relative 'datacircle/calls'
8
+ require_relative 'datacircle/tools'
9
+
10
+ module Agents
11
+ # Datacircle's open API as four tools of ai-agents, with no key: find the best GTM APIs. We benchmark all the GTM APIs
12
+ # and we put the results on our website, https://datacircle.dev
13
+ #
14
+ # Agents::Agent.new(name: ..., instructions: ..., tools: Agents::Datacircle.tools)
15
+ #
16
+ # datacircle_list_apis, datacircle_best_plans, datacircle_search_plans and datacircle_provider make one GET of
17
+ # https://api.datacircle.dev/v1 each and answer its JSON as text, or {"error": ...} with the API's words.
18
+ module Datacircle
19
+ TOOLS = [ListApis, BestPlans, SearchPlans, Provider].freeze
20
+
21
+ # The four tools, for an agent's tools:. base_url: where they call, https://api.datacircle.dev/v1 when left out.
22
+ def self.tools(base_url: nil)
23
+ TOOLS.map { |tool| tool.new(base_url: base_url) }
24
+ end
25
+ end
26
+ end
@@ -0,0 +1,4 @@
1
+ # frozen_string_literal: true
2
+
3
+ # Bundler.require loads a gem by its name: this loads the tools for an app that lists gem 'ai-agents-datacircle'.
4
+ require_relative 'agents/datacircle'
metadata ADDED
@@ -0,0 +1,75 @@
1
+ --- !ruby/object:Gem::Specification
2
+ name: ai-agents-datacircle
3
+ version: !ruby/object:Gem::Version
4
+ version: 0.1.0
5
+ platform: ruby
6
+ authors:
7
+ - Wayne Hamadi
8
+ bindir: bin
9
+ cert_chain: []
10
+ date: 1980-01-02 00:00:00.000000000 Z
11
+ dependencies:
12
+ - !ruby/object:Gem::Dependency
13
+ name: ai-agents
14
+ requirement: !ruby/object:Gem::Requirement
15
+ requirements:
16
+ - - ">="
17
+ - !ruby/object:Gem::Version
18
+ version: 0.13.0
19
+ - - "<"
20
+ - !ruby/object:Gem::Version
21
+ version: '1'
22
+ type: :runtime
23
+ prerelease: false
24
+ version_requirements: !ruby/object:Gem::Requirement
25
+ requirements:
26
+ - - ">="
27
+ - !ruby/object:Gem::Version
28
+ version: 0.13.0
29
+ - - "<"
30
+ - !ruby/object:Gem::Version
31
+ version: '1'
32
+ description: 'The gem gives your agents four tools. They call Datacircle''s open API
33
+ with no key. List the GTM APIs and each API''s best plans. Search every plan, or
34
+ see where one provider ranks in our benchmarks. We benchmark all the GTM APIs and
35
+ we put the results on our website: https://datacircle.dev'
36
+ email:
37
+ - wayne@datacircle.dev
38
+ executables: []
39
+ extensions: []
40
+ extra_rdoc_files: []
41
+ files:
42
+ - LICENSE.txt
43
+ - README.md
44
+ - lib/agents/datacircle.rb
45
+ - lib/agents/datacircle/calls.rb
46
+ - lib/agents/datacircle/client.rb
47
+ - lib/agents/datacircle/tools.rb
48
+ - lib/agents/datacircle/version.rb
49
+ - lib/ai-agents-datacircle.rb
50
+ homepage: https://datacircle.dev
51
+ licenses:
52
+ - MIT
53
+ metadata:
54
+ homepage_uri: https://datacircle.dev
55
+ source_code_uri: https://github.com/waynehamadi/ai-agents-datacircle
56
+ documentation_uri: https://github.com/waynehamadi/ai-agents-datacircle#readme
57
+ bug_tracker_uri: https://github.com/waynehamadi/ai-agents-datacircle/issues
58
+ rdoc_options: []
59
+ require_paths:
60
+ - lib
61
+ required_ruby_version: !ruby/object:Gem::Requirement
62
+ requirements:
63
+ - - ">="
64
+ - !ruby/object:Gem::Version
65
+ version: 3.2.0
66
+ required_rubygems_version: !ruby/object:Gem::Requirement
67
+ requirements:
68
+ - - ">="
69
+ - !ruby/object:Gem::Version
70
+ version: '0'
71
+ requirements: []
72
+ rubygems_version: 3.6.9
73
+ specification_version: 4
74
+ summary: Agents built with the ai-agents gem can find the best GTM APIs for you.
75
+ test_files: []