Ready-to-use integration code for Claw Ecosystem APIs
import requests
from typing import List, Dict
class ClawsAPI:
"""Simple Python client for Claw Ecosystem API"""
def __init__(self):
self.base_url = "https://claw-news.com/api"
def get_all_variants(self) -> List[Dict]:
"""Fetch all Claw variants"""
response = requests.get(f"{self.base_url}/claws")
return response.json()
def get_by_category(self, category: str) -> List[Dict]:
"""Filter variants by category"""
all_variants = self.get_all_variants()
return [v for v in all_variants if v.get('category') == category]
def find_lightest(self) -> Dict:
"""Find variant with lowest memory usage"""
variants = self.get_all_variants()
return min(variants, key=lambda v: self._parse_memory(v.get('memory_footprint', '9999MB')))
def _parse_memory(self, memory_str: str) -> int:
"""Convert memory string to MB integer"""
try:
return int(memory_str.replace('MB', '').replace('~', '').strip())
except:
return 9999
# Usage
if __name__ == "__main__":
api = ClawsAPI()
# Get all variants
variants = api.get_all_variants()
print(f"Found {len(variants)} variants")
# Get Chinese enterprise variants
chinese = api.get_by_category('chinese-enterprise')
print(f"Chinese variants: {len(chinese)}")
for v in chinese:
print(f" - {v['name']} by {v['developer']}")
# Find lightest variant
lightest = api.find_lightest()
print(f"\nLightest: {lightest['name']} ({lightest['memory_footprint']})")def search_variants(query: str) -> List[Dict]:
"""Semantic search across all variants"""
response = requests.get(
"https://claw-news.com/api/claws/search",
params={"q": query}
)
data = response.json()
return data.get('results', [])
# Search for lightweight variants
results = search_variants("lightweight minimal low memory")
for result in results:
print(f"{result['name']} (score: {result['relevance_score']:.2f})")
print(f" {result['description'][:100]}...")def compare_variants(slugs: List[str]) -> Dict:
"""Compare multiple variants side-by-side"""
slugs_param = ",".join(slugs)
response = requests.get(
"https://claw-news.com/api/claws/compare",
params={"slugs": slugs_param}
)
return response.json()
# Compare OpenClaw, NemoClaw, and ZeroClaw
comparison = compare_variants(["openclaw", "nemoclaw", "zeroclaw"])
print("\nComparison Results:")
for variant in comparison['comparison']:
print(f"\n{variant['name']}:")
print(f" Memory: {variant['memory_footprint']}")
print(f" Size: {variant['binary_size']}")
print(f" Developer: {variant['developer']}")
print(f"\nBest for low memory: {comparison['metrics']['lowest_memory']}")class ClawsClient {
constructor() {
this.baseUrl = 'https://claw-news.com/api';
this.cache = new Map();
}
async getAllVariants() {
const cacheKey = 'all_variants';
if (this.cache.has(cacheKey)) {
return this.cache.get(cacheKey);
}
const response = await fetch(`${this.baseUrl}/claws`);
const data = await response.json();
this.cache.set(cacheKey, data);
return data;
}
async getByCategory(category) {
const variants = await this.getAllVariants();
return variants.filter(v => v.category === category);
}
async search(query) {
const response = await fetch(
`${this.baseUrl}/claws/search?q=${encodeURIComponent(query)}`
);
return await response.json();
}
async compare(slugs) {
const response = await fetch(
`${this.baseUrl}/claws/compare?slugs=${slugs.join(',')}`
);
return await response.json();
}
async getStats() {
const response = await fetch(`${this.baseUrl}/ecosystem/stats`);
return await response.json();
}
}
// Usage
async function main() {
const client = new ClawsClient();
// Get all variants
const variants = await client.getAllVariants();
console.log(`Total variants: ${variants.length}`);
// Search for enterprise variants
const searchResults = await client.search('enterprise security');
console.log('Search results:', searchResults.results.length);
// Compare top variants
const comparison = await client.compare(['openclaw', 'nemoclaw']);
console.log('Comparison:', comparison.comparison.length, 'variants');
// Get ecosystem stats
const stats = await client.getStats();
console.log('Ecosystem stats:', stats);
}
main();import React, { useState, useEffect } from 'react';
function VariantsList() {
const [variants, setVariants] = useState([]);
const [loading, setLoading] = useState(true);
const [category, setCategory] = useState('all');
useEffect(() => {
fetchVariants();
}, []);
const fetchVariants = async () => {
try {
const response = await fetch('https://claw-news.com/api/claws');
const data = await response.json();
setVariants(data);
} catch (error) {
console.error('Error fetching variants:', error);
} finally {
setLoading(false);
}
};
const filteredVariants = category === 'all'
? variants
: variants.filter(v => v.category === category);
if (loading) return Loading...;
return (
{filteredVariants.map(variant => (
{variant.name}
by {variant.developer}
{variant.positioning}
{variant.description.substring(0, 150)}...
Memory: {variant.memory_footprint}
Size: {variant.binary_size}
{variant.homepage && (
Visit Website →
)}
))}
);
}
export default VariantsList;# Get all variants
curl https://claw-news.com/api/claws | jq '.'
# Get just names
curl https://claw-news.com/api/claws | jq '.[].name'
# Search for lightweight variants
curl "https://claw-news.com/api/claws/search?q=lightweight" | jq '.results[] | {name, score: .relevance_score}'
# Compare OpenClaw and NemoClaw
curl "https://claw-news.com/api/claws/compare?slugs=openclaw,nemoclaw" | jq '.comparison[] | {name, memory: .memory_footprint}'
# Get ecosystem statistics
curl https://claw-news.com/api/ecosystem/stats | jq '.'
# Filter by category (using jq)
curl https://claw-news.com/api/claws | jq '[.[] | select(.category == "chinese-enterprise")] | length'
# Find variant with smallest binary size
curl https://claw-news.com/api/claws | jq 'min_by(.binary_size) | {name, size: .binary_size}'
# Get variants with homepages only
curl https://claw-news.com/api/claws | jq '[.[] | select(.homepage != null)] | length'from langchain.agents import Tool, AgentExecutor, ChatAgent
from langchain.llms import OpenAI
from langchain.memory import ConversationBufferMemory
import requests
# Define Claw Ecosystem tools
def search_claws(query):
"""Search Claw variants semantically"""
response = requests.get(
"https://claw-news.com/api/claws/search",
params={"q": query}
)
data = response.json()
results = data.get('results', [])
return "\n".join([
f"{r['name']}: {r['description'][:100]}... (score: {r['relevance_score']:.2f})"
for r in results[:3]
])
def compare_claws(slugs):
"""Compare multiple Claw variants"""
response = requests.get(
"https://claw-news.com/api/claws/compare",
params={"slugs": slugs}
)
data = response.json()
comparison = data.get('comparison', [])
return "\n".join([
f"{v['name']}: Memory={v['memory_footprint']}, Size={v['binary_size']}"
for v in comparison
])
def get_ecosystem_stats():
"""Get overall ecosystem statistics"""
response = requests.get("https://claw-news.com/api/ecosystem/stats")
data = response.json()
return f"""Total variants: {data['total_variants']}
Categories: {data['categories']}
Lightest: {data['lightest_variant']['name']} ({data['lightest_variant']['memory']})
Heaviest: {data['heaviest_variant']['name']} ({data['heaviest_variant']['memory']})"""
# Create tools
tools = [
Tool(
name="Search Claws",
func=search_claws,
description="Use this to search for Claw variants by features, memory usage, or capabilities"
),
Tool(
name="Compare Claws",
func=compare_claws,
description="Use this to compare multiple Claw variants side-by-side. Pass comma-separated slugs."
),
Tool(
name="Ecosystem Stats",
func=get_ecosystem_stats,
description="Use this to get overall statistics about the Claw ecosystem"
)
]
# Create agent
llm = OpenAI(temperature=0)
memory = ConversationBufferMemory()
agent = ChatAgent(
llm=llm,
tools=tools,
verbose=True
)
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
memory=memory,
verbose=True
)
# Run agent
response = agent_executor.run("Which Claw variant is best for low memory usage? Compare the top 3 options.")
print(response)