aris-sdk 0.1.0__tar.gz

aris_sdk-0.1.0/LICENSE

@@ -0,0 +1,5 @@
+MIT License
+
+Copyright (c) 2026 Siddhant Porwal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files...

aris_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: aris-sdk
+Version: 0.1.0
+Summary: Decentralized AI Network SDK and Node Infrastructure
+Author: Sid
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: pydantic
+Requires-Dist: python-jose[cryptography]
+Requires-Dist: uvicorn
+Requires-Dist: fastapi
+Requires-Dist: httpx
+Requires-Dist: pyjwt
+Requires-Dist: python-dotenv
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

aris_sdk-0.1.0/README.md

@@ -0,0 +1,110 @@
+# Aris SDK 🚀
+### The Decentralized AI Network Layer
+
+Aris is a lightweight, decentralized infrastructure for local LLM inference. It allows users to contribute compute power as "Worker Nodes" and developers to consume that AI compute via a unified SDK with built-in micro-payments and registry management.
+
+---
+
+## 🛠 Features
+- **Decentralized Registry**: On-chain style ledger for managing API keys and balances.
+- **Worker Nodes**: Easily turn any machine with a local LLM into a revenue-generating node.
+- **Standardized SDK**: OpenAI-compatible interface for easy integration.
+- **Transparent Billing**: Built-in balance deduction per inference request.
+
+---
+
+## 📦 Installation
+
+Install the core SDK via pip:
+
+```bash
+pip install aris-sdk
+
+```
+
+---
+
+## 🚀 Quick Start (Client Side)
+
+To use the network as a developer, simply initialize the `Aris` client with your API key.
+
+```python
+from aris.client import Aris
+
+# Initialize with your minted key
+client = Aris(api_key="sk-aris-your-unique-key")
+
+# Generate a response from the decentralized swarm
+response = client.generate("Why is the ocean salty?")
+
+print(f"🤖 ARIS: {response}")
+
+```
+
+---
+
+## 🏗 Infrastructure Setup
+
+### 1. Start the Registry
+
+The Registry acts as the "Bank" and "DNS" of the network.
+
+```bash
+# Run the registry server (Default port: 8000)
+python3 -m registry.main
+
+```
+
+### 2. Join as a Worker Node
+
+Nodes register themselves with the Registry and wait for inference jobs.
+
+```bash
+# Start a node on port 9006
+aris-node --port 9006
+
+```
+
+### 3. Admin: Minting New Keys
+
+Manage your network users using the admin CLI.
+
+```bash
+# Create a new user with a 500 credit balance
+aris-admin --email user@example.com --balance 500.0
+
+```
+
+---
+
+## 📂 Project Structure
+
+* `/aris`: The core Client SDK logic.
+* `/agent_node`: Worker node infrastructure and LLM integration (TinyLlama).
+* `/registry`: Centralized ledger for account and node management.
+
+---
+
+## 📜 License
+
+Distributed under the MIT License. See `LICENSE` for more information.
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+**Built with ❤️ for the Decentralized AI Community.**
+
+```
+
+---
+
+### **Final Pro-Tip for the Launch**
+Before you run `python3 -m twine upload dist/*`, make sure your `LICENSE` file exists. You can create a quick one like this:
+
+```bash
+echo "Copyright (c) 2026 Sid - MIT License" > LICENSE
+
+```

aris_sdk-0.1.0/agent_node/llm_agent.py

@@ -0,0 +1,70 @@
+import uvicorn
+import jwt
+import os
+import httpx 
+import asyncio
+import argparse
+from fastapi import FastAPI, HTTPException, Header
+from pydantic import BaseModel
+
+app = FastAPI(title="Aris Node: LLM Specialist")
+
+# --- CONFIG ---
+REGISTRY_URL = os.getenv("ARIS_REGISTRY", "http://localhost:8000/register")
+MY_DID = "did:aris:llm-node-01"
+MY_ENDPOINT = "http://localhost:9006"
+ARIS_PUBLIC_KEY = "s3cret_k3y_for_signing_tokens" 
+OLLAMA_URL = "http://localhost:11434/api/generate"
+
+# --- AUTO-REGISTER ON STARTUP ---
+@app.on_event("startup")
+async def start_heartbeat():
+    async def heartbeat():
+        while True:
+            async with httpx.AsyncClient() as client:
+                try:
+                    await client.post(REGISTRY_URL, json={
+                        "did": MY_DID,
+                        "endpoint": MY_ENDPOINT,
+                        "capabilities": ["ai.generate"]
+                    })
+                    print("💓 Heartbeat: Registry updated.")
+                except Exception:
+                    print("⚠️ Heartbeat: Registry unreachable...")
+            await asyncio.sleep(30) # Check in every 30 seconds
+            
+    asyncio.create_task(heartbeat())
+
+# --- MODELS & ENDPOINTS ---
+class PromptRequest(BaseModel):
+    model: str = "tinyllama"
+    prompt: str
+
+@app.post("/generate")
+async def generate_text(job: PromptRequest, x_aris_token: str = Header(...)):
+    try:
+        # Verify the session token issued by the Registry
+        payload = jwt.decode(x_aris_token, ARIS_PUBLIC_KEY, algorithms=["HS256"], audience=MY_DID)
+    except jwt.InvalidTokenError:
+        raise HTTPException(401, "Invalid or Expired Token")
+
+    print(f"🧠 [LLM Node] Processing for {payload['sub']}...")
+
+    async with httpx.AsyncClient() as client:
+        resp = await client.post(OLLAMA_URL, json={
+            "model": job.model, "prompt": job.prompt, "stream": False
+        }, timeout=60.0)
+        return {"result": resp.json().get("response", ""), "status": "success"}
+
+def main():
+    parser = argparse.ArgumentParser(description="Aris Worker Node")
+    parser.add_argument("--port", type=int, default=9006, help="Port to run the agent on")
+    parser.add_argument("--model", type=str, default="tinyllama", help="Ollama model to use")
+    args = parser.parse_args()
+
+    print(f"🚀 Starting Aris Node on port {args.port} using {args.model}...")
+    uvicorn.run(app, host="0.0.0.0", port=args.port)
+    
+    
+if __name__ == "__main__":
+    main()

aris_sdk-0.1.0/agent_node/main.py

@@ -0,0 +1,52 @@
+import sys
+import argparse
+import uvicorn
+import base64
+import hmac
+import hashlib
+import time
+import ollama
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+
+# --- 1. SETUP DYNAMIC ARGS ---
+parser = argparse.ArgumentParser()
+parser.add_argument("--port", type=int, default=9001)
+parser.add_argument("--name", type=str, default="Unknown Agent")
+args, _ = parser.parse_known_args()
+
+app = FastAPI(title=f"Aris Node: {args.name}")
+
+# --- CONFIG ---
+ARIS_SECRET_KEY = b"super_secret_platform_key_2025"
+MODEL_NAME = "tinyllama" 
+
+class JobRequest(BaseModel):
+    prompt: str
+    session_token: str
+
+@app.post("/process_job")
+async def process_job(job: JobRequest):
+    # AUTH (Same as before)
+    try:
+        if "." not in job.session_token: raise ValueError("Invalid token")
+        payload_b64, signature = job.session_token.split(".")
+        expected_sig = hmac.new(ARIS_SECRET_KEY, base64.b64decode(payload_b64), hashlib.sha256).hexdigest()
+        if not hmac.compare_digest(signature, expected_sig): raise HTTPException(401, "FAKE TOKEN")
+    except Exception as e:
+        raise HTTPException(401, str(e))
+
+    # INTELLIGENCE
+    print(f"[{args.name}] Thinking...")
+    try:
+        response = ollama.chat(model=MODEL_NAME, messages=[{'role': 'user', 'content': job.prompt}])
+        return {
+            "node": args.name,
+            "response": response['message']['content']
+        }
+    except Exception as e:
+        raise HTTPException(500, str(e))
+
+if __name__ == "__main__":
+    # This allows us to run: python main.py --port 9002
+    uvicorn.run(app, host="0.0.0.0", port=args.port)

aris_sdk-0.1.0/agent_node/math_agent.py

@@ -0,0 +1,44 @@
+import uvicorn
+import jwt
+from fastapi import FastAPI, HTTPException, Header
+from pydantic import BaseModel
+
+app = FastAPI(title="Aris Node: Math Specialist")
+
+# The Agent needs the Registry's Public Key (or shared secret for HS256) to verify tokens
+ARIS_PUBLIC_KEY = "s3cret_k3y_for_signing_tokens" 
+
+class JobRequest(BaseModel):
+    a: int
+    b: int
+    operation: str # "add"
+
+@app.post("/execute")
+async def execute_task(job: JobRequest, x_aris_token: str = Header(...)):
+    """
+    Section 3C: Agent verifies the token before working.
+    """
+    try:
+        # 1. Verify the signature (Did Aris sign this?)
+        payload = jwt.decode(x_aris_token, ARIS_PUBLIC_KEY, algorithms=["HS256"], audience="did:aris:math-node-01")
+        
+        # 2. Check Scope
+        if "math.add" not in payload.get("scope", ""):
+            raise HTTPException(403, "Token not valid for math.add")
+            
+        print(f"🤖 [Agent] Token Verified! Processing job for {payload['sub']}")
+
+    except jwt.ExpiredSignatureError:
+        raise HTTPException(401, "Token Expired")
+    except jwt.InvalidTokenError as e:
+        raise HTTPException(401, f"Invalid Token: {str(e)}")
+
+    # 3. Do the Work (The Capability)
+    if job.operation == "add":
+        return {"result": job.a + job.b, "status": "success"}
+    
+    return {"error": "Unsupported operation"}
+
+if __name__ == "__main__":
+    # Runs on Port 9005 (Math Node)
+    uvicorn.run(app, host="0.0.0.0", port=9005)

aris_sdk-0.1.0/aris/__init__.py

@@ -0,0 +1,4 @@
+# aris/__init__.py
+from .client import Aris, generate
+
+__version__ = "0.2.0"

aris_sdk-0.1.0/aris/client.py

@@ -0,0 +1,137 @@
+import os
+import requests
+import logging
+from typing import Optional, Dict, Any
+
+# Configure library logging (NullHandler by default so we don't spam unless configured)
+logger = logging.getLogger("aris")
+logger.addHandler(logging.NullHandler())
+
+# --- Custom Exceptions (The Professional Way) ---
+class ArisError(Exception):
+    """Base exception for all Aris SDK errors."""
+    pass
+
+class ArisPaymentError(ArisError):
+    """Raised when payment fails or balance is insufficient."""
+    pass
+
+class ArisNodeError(ArisError):
+    """Raised when the worker node fails to respond."""
+    pass
+
+# --- The Main Client ---
+class Aris:
+    def __init__(self, api_key: Optional[str] = None, registry_url: Optional[str] = None):
+        """
+        Initialize the Aris Client.
+        
+        Args:
+            api_key: Your Aris API Key (starts with sk-). Defaults to ARIS_API_KEY env var.
+            registry_url: URL of the Aris Registry. Defaults to ARIS_REGISTRY_URL env var or localhost.
+        """
+        self.api_key = api_key or os.getenv("ARIS_API_KEY")
+        if not self.api_key:
+            raise ArisError("❌ Missing API Key. Pass it to Aris() or set ARIS_API_KEY.")
+            
+        self.registry_url = registry_url or os.getenv("ARIS_REGISTRY_URL", "http://localhost:8000")
+        self.session_token: Optional[str] = None
+        self.target_endpoint: Optional[str] = None
+
+    def generate(self, prompt: str, model: str = "tinyllama") -> str:
+        """
+        Generate text using the decentralized Aris network.
+        
+        Args:
+            prompt: The text prompt to send.
+            model: The model to use (default: tinyllama).
+            
+        Returns:
+            The generated text string.
+        """
+        # Auto-connect if not connected
+        if not self.session_token:
+            self._connect_to_swarm()
+
+        try:
+            return self._execute_request(prompt, model)
+        except ArisError as e:
+            # If token expired, try one refresh
+            logger.warning(f"⚠️ Request failed ({e}). Attempting to refresh session...")
+            self.session_token = None
+            self._connect_to_swarm()
+            return self._execute_request(prompt, model)
+
+    def _connect_to_swarm(self):
+        """Handles Discovery (finding nodes) and Handshake (payment)."""
+        logger.info("🔎 Discovering best available node...")
+        
+        try:
+            # 1. Discover
+            resp = requests.get(f"{self.registry_url}/discover", params={"capability": "ai.generate"}, timeout=5)
+            resp.raise_for_status()
+            data = resp.json()
+            
+            if not data.get("agents"):
+                raise ArisNodeError("No active worker nodes found in the network.")
+            
+            # Simple routing: Pick the first one (Future: pick based on latency/price)
+            target = data["agents"][0]
+            self.target_endpoint = target["endpoint"]
+            target_did = target["did"]
+
+            # 2. Handshake (The Transaction)
+            logger.info(f"💳 Negotiating contract with {target_did}...")
+            
+            pay_resp = requests.post(
+                f"{self.registry_url}/handshake",
+                json={
+                    "payer_did": "did:aris:customer-sdk", # In future, derive this from key
+                    "target_did": target_did,
+                    "capability": "ai.generate"
+                },
+                headers={"x-api-key": self.api_key},
+                timeout=10
+            )
+
+            if pay_resp.status_code == 402:
+                raise ArisPaymentError("Insufficient Balance. Please top up your Aris account.")
+            elif pay_resp.status_code != 200:
+                raise ArisError(f"Handshake failed: {pay_resp.text}")
+
+            session_data = pay_resp.json()
+            self.session_token = session_data["session_token"]
+            
+            logger.info(f"✅ Session Established. Balance remaining: ₹{session_data.get('remaining_balance', '???')}")
+
+        except requests.RequestException as e:
+            raise ArisError(f"Network error connecting to Registry: {e}")
+
+    def _execute_request(self, prompt: str, model: str) -> str:
+        """Direct Peer-to-Peer execution with the Worker Node."""
+        if not self.target_endpoint:
+            raise ArisError("No target endpoint configured.")
+
+        try:
+            response = requests.post(
+                f"{self.target_endpoint}/generate",
+                json={"model": model, "prompt": prompt},
+                headers={"x-aris-token": self.session_token},
+                timeout=60 # AI can be slow
+            )
+
+            if response.status_code == 200:
+                return response.json().get("result", "")
+            elif response.status_code in [401, 403]:
+                raise ArisError("Session Token Expired or Invalid")
+            else:
+                raise ArisNodeError(f"Worker Node Error: {response.text}")
+                
+        except requests.RequestException as e:
+            raise ArisNodeError(f"Failed to communicate with Worker Node: {e}")
+
+# --- Helper for quick scripts ---
+def generate(prompt: str, api_key: Optional[str] = None) -> str:
+    """Quick helper function for one-off generations."""
+    client = Aris(api_key=api_key)
+    return client.generate(prompt)

aris_sdk-0.1.0/aris_sdk.egg-info/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: aris-sdk
+Version: 0.1.0
+Summary: Decentralized AI Network SDK and Node Infrastructure
+Author: Sid
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: pydantic
+Requires-Dist: python-jose[cryptography]
+Requires-Dist: uvicorn
+Requires-Dist: fastapi
+Requires-Dist: httpx
+Requires-Dist: pyjwt
+Requires-Dist: python-dotenv
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

aris_sdk-0.1.0/aris_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+setup.py
+agent_node/__init__.py
+agent_node/llm_agent.py
+agent_node/main.py
+agent_node/math_agent.py
+aris/__init__.py
+aris/client.py
+aris/types.py
+aris_sdk.egg-info/PKG-INFO
+aris_sdk.egg-info/SOURCES.txt
+aris_sdk.egg-info/dependency_links.txt
+aris_sdk.egg-info/entry_points.txt
+aris_sdk.egg-info/requires.txt
+aris_sdk.egg-info/top_level.txt
+registry/__init__.py
+registry/main.py
+registry/mint_key.py
+registry/models.py
+registry/search.py

aris_sdk-0.1.0/aris_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aris_sdk-0.1.0/aris_sdk.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+aris-admin = registry.mint_key:main
+aris-node = agent_node.llm_agent:main

aris_sdk-0.1.0/aris_sdk.egg-info/requires.txt

@@ -0,0 +1,8 @@
+requests
+pydantic
+python-jose[cryptography]
+uvicorn
+fastapi
+httpx
+pyjwt
+python-dotenv

aris_sdk-0.1.0/aris_sdk.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+agent_node
+aris
+registry

aris_sdk-0.1.0/registry/main.py

@@ -0,0 +1,155 @@
+import time
+import json
+import jwt  # pip install pyjwt
+from fastapi import FastAPI, HTTPException, Header
+from pydantic import BaseModel
+from typing import List, Dict, Optional
+
+# --- CONFIG ---
+ARIS_PRIVATE_KEY = "s3cret_k3y_for_signing_tokens"
+MVP_PRICE_INR = 20.00
+LEDGER_FILE = "registry/accounts.json"
+
+app = FastAPI(title="Aris Registry (Paid)", version="0.2")
+
+# --- DATA STORES ---
+service_registry: Dict[str, List[dict]] = {}
+ledger: Dict[str, dict] = {} 
+
+# --- HELPER FUNCTIONS ---
+def load_accounts():
+    try:
+        with open(LEDGER_FILE, "r") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        return {}
+
+def save_accounts(data):
+    with open(LEDGER_FILE, "w") as f:
+        json.dump(data, f, indent=4)
+        
+def validate_api_key(api_key: str):
+    # Load your ledger
+    with open("registry/accounts.json", "r") as f:
+        accounts = json.load(f)
+    
+    # Check 1: Does key exist?
+    if api_key not in accounts:
+        raise HTTPException(status_code=401, detail="Invalid API Key")
+    
+    # Check 2: Is the account enabled?
+    user = accounts[api_key]
+    if not user.get("active", False):
+        raise HTTPException(status_code=403, detail="Account suspended")
+        
+    # Check 3: Does it have money?
+    if user.get("balance", 0) <= 0:
+        raise HTTPException(status_code=402, detail="Insufficient funds")
+        
+    return user
+
+# --- MODELS ---
+class AgentRegistration(BaseModel):
+    did: str
+    endpoint: str
+    capabilities: List[str]
+
+class SessionRequest(BaseModel):
+    payer_did: str
+    target_did: str
+    capability: str
+
+# --- ENDPOINTS ---
+
+@app.post("/register")
+async def register_agent(agent: AgentRegistration):
+    for cap in agent.capabilities:
+        if cap not in service_registry:
+            service_registry[cap] = []
+        # Update existing agent or add new
+        service_registry[cap] = [a for a in service_registry[cap] if a['did'] != agent.did]
+        service_registry[cap].append(agent.dict())
+    
+    print(f"✅ [Registry] Registered {agent.did}")
+    return {"status": "registered"}
+
+@app.get("/discover")
+async def discover(capability: str):
+    agents = service_registry.get(capability, [])
+    if not agents:
+        raise HTTPException(404, "No agents found")
+    return {"agents": agents}
+
+@app.post("/handshake")
+async def handshake(req: SessionRequest, x_api_key: Optional[str] = Header(None)):
+    """
+    💰 PAYMENT LOGIC:
+    1. Check Key
+    2. Check Balance
+    3. Deduct Fee
+    4. Issue Token
+    """
+    # 1. AUTH
+    if not x_api_key:
+        raise HTTPException(401, "Missing API Key")
+
+    accounts = load_accounts()
+    if x_api_key not in accounts:
+        raise HTTPException(403, "Invalid API Key")
+
+    user_account = accounts[x_api_key]
+
+    if not user_account["active"]:
+        raise HTTPException(403, "Account Suspended")
+
+    # 2. CHECK BALANCE
+    if user_account["balance"] < MVP_PRICE_INR:
+        raise HTTPException(402, "Insufficient Balance. Please Top Up.")
+
+    # 3. CHARGE
+    user_account["balance"] -= MVP_PRICE_INR
+    save_accounts(accounts) # Save to disk
+    
+    print(f"💰 [Billing] Charged {x_api_key[:10]}... | New Balance: ₹{user_account['balance']}")
+
+    # 4. ISSUE TOKEN
+    txn_id = f"txn_{int(time.time())}"
+    payload = {
+        "iss": "aris-registry",
+        "sub": req.payer_did,
+        "aud": req.target_did,
+        "scope": req.capability,
+        "txn_id": txn_id,
+        "exp": time.time() + 300 # 5 mins
+    }
+    
+    token = jwt.encode(payload, ARIS_PRIVATE_KEY, algorithm="HS256")
+
+    return {
+        "session_token": token,
+        "txn_id": txn_id,
+        "remaining_balance": user_account["balance"]
+    }
+    
+class TopUpRequest(BaseModel):
+    api_key: str
+    amount: float
+
+@app.post("/admin/topup")
+async def top_up(req: TopUpRequest):
+    accounts = load_accounts()
+    if req.api_key not in accounts:
+        raise HTTPException(404, "Key not found")
+    
+    accounts[req.api_key]["balance"] += req.amount
+    save_accounts(accounts)
+    
+    return {
+        "status": "success", 
+        "new_balance": accounts[req.api_key]["balance"]
+    }
+    
+if __name__ == "__main__":
+    import uvicorn
+    # This actually starts the server
+    uvicorn.run(app, host="0.0.0.0", port=8000)

aris_sdk-0.1.0/registry/mint_key.py

@@ -0,0 +1,53 @@
+import secrets
+import json
+import os
+import argparse
+from datetime import datetime
+
+ACCOUNTS_FILE = "registry/accounts.json"
+
+def mint_key(email: str, balance: float = 100.0):
+    """Business logic to create the key and update the ledger."""
+    new_key = f"sk-aris-{secrets.token_hex(16)}"
+    
+    # Ensure directory exists
+    os.makedirs(os.path.dirname(ACCOUNTS_FILE), exist_ok=True)
+
+    if os.path.exists(ACCOUNTS_FILE):
+        with open(ACCOUNTS_FILE, "r") as f:
+            accounts = json.load(f)
+    else:
+        accounts = {}
+
+    accounts[new_key] = {
+        "user_email": email,
+        "balance": balance,
+        "active": True,
+        "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+
+    with open(ACCOUNTS_FILE, "w") as f:
+        json.dump(accounts, f, indent=4)
+
+    print(f"\n✨ Aris Key Minted Successfully!")
+    print(f"📧 User:    {email}")
+    print(f"💰 Balance: ₹{balance}")
+    print(f"🔑 Key:     {new_key}")
+    print(f"--------------------------------------------------")
+    return new_key
+
+def main():
+    """CLI Entrypoint for the aris-admin command."""
+    parser = argparse.ArgumentParser(description="Aris Network Admin Tools")
+    parser.add_argument("--email", help="Email of the user")
+    parser.add_argument("--balance", type=float, default=100.0, help="Starting balance")
+    args = parser.parse_args()
+
+    # If user didn't provide an email via flags, ask interactively
+    email = args.email or input("Enter user email: ")
+    balance = args.balance if args.email else (input("Enter starting balance (default 100.0): ") or 100.0)
+    
+    mint_key(email, float(balance))
+
+if __name__ == "__main__":
+    main()

aris_sdk-0.1.0/registry/search.py

@@ -0,0 +1,60 @@
+import redis.asyncio as redis
+from typing import List, Optional
+
+# Connect to Redis
+redis_client = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)
+
+class SearchEngine:
+    """
+    The 'Google' of Aris.
+    Uses Inverted Indices in Redis to find agents by capability instantly.
+    """
+
+    @staticmethod
+    async def index_agent(did: str, capabilities: List[str]):
+        """
+        Updates the Inverted Index.
+        If Agent A has 'video', we add Agent A to the 'idx:video' set.
+        """
+        async with redis_client.pipeline() as pipe:
+            # 1. Update the 'Last Seen' timestamp
+            pipe.hset(f"agent:{did}", mapping={"last_seen": "now"})
+            
+            # 2. Index each capability
+            for cap in capabilities:
+                # Key: idx:media.video -> Set{did:agent:1, did:agent:2}
+                pipe.sadd(f"idx:{cap.lower()}", did)
+            
+            await pipe.execute()
+
+    @staticmethod
+    async def search(capability: str, limit: int = 10) -> List[dict]:
+        """
+        Finds agents that match the capability.
+        Returns full agent details.
+        """
+        # 1. Get all DIDs from the index (0ms latency)
+        dids = await redis_client.smembers(f"idx:{capability.lower()}")
+        
+        if not dids:
+            return []
+
+        # 2. Fetch details for all found agents in parallel
+        results = []
+        for did in list(dids)[:limit]:
+            # In a real app, use mget for even more speed
+            data = await redis_client.hgetall(f"agent:{did}")
+            if data:
+                # Add the DID to the response object since it's the key
+                data['did'] = did
+                results.append(data)
+                
+        return results
+
+    @staticmethod
+    async def remove_agent(did: str, capabilities: List[str]):
+        """
+        Removes an agent from the index (e.g., if they go offline).
+        """
+        for cap in capabilities:
+            await redis_client.srem(f"idx:{cap.lower()}", did)

aris_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aris_sdk-0.1.0/setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="aris-sdk",
+    version="0.1.0",
+    description="Decentralized AI Network SDK and Node Infrastructure",
+    author="Sid",
+    packages=find_packages(include=[
+        "aris", "aris.*", 
+        "agent_node", "agent_node.*", 
+        "registry", "registry.*"
+    ]),
+    install_requires=[
+        "requests",
+        "pydantic",
+        "python-jose[cryptography]",
+        "uvicorn",
+        "fastapi",
+        "httpx",
+        "pyjwt",
+        "python-dotenv"
+    ],
+    entry_points={
+        "console_scripts": [
+            "aris-node=agent_node.llm_agent:main",
+            "aris-admin=registry.mint_key:main",
+        ],
+    },
+    python_requires=">=3.8",
+)