MODAC GLOBAL SYSTEM

This is a submission for the Xano AI-Powered Backend Challenge: Full-Stack, AI-First Application

What I Built

<!-- Test locally: pip install -r requirements.txt && uvicorn main:app --reload. Endpoints: /api/register (POST agent), /api/agents (GET list), /api/transactions (POST txn).

1. requirements.txt fastapi==0.115.0 uvicorn==0.30.6 sqlalchemy==2.0.36 psycopg2-binary==2.9.9 # For Postgres; use sqlite3 for local pydantic==2.9.2 stripe==10.6.0 # For revenue stubs python-multipart==0.0.9 # For form data
2. models.py (DB Models) from sqlalchemy import create_engine, Column, String, Text, Float, DateTime, Integer, ForeignKey from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker from datetime import datetime

Base = declarative_base()

class Agent(Base):
tablename = "agents"
id = Column(Integer, primary_key=True, index=True)
agent_id = Column(String(50), unique=True, index=True)
name = Column(String(100))
description = Column(Text)
creator_email = Column(String(120))
framework = Column(String(50))
tags = Column(Text) # Comma-separated
website = Column(String(200))
github = Column(String(200))
trust_score = Column(Float, default=50.0)
monthly_calls = Column(Integer, default=0)
human_verified = Column(Integer, default=0)
featured = Column(Integer, default=0)
status = Column(String(20), default="live")
created_at = Column(DateTime, default=datetime.utcnow)

class Transaction(Base):
tablename = "transactions"
id = Column(Integer, primary_key=True, index=True)
txn_id = Column(String(50), unique=True, index=True)
buyer_agent_id = Column(String(50), ForeignKey("agents.agent_id"))
seller_agent_id = Column(String(50), ForeignKey("agents.agent_id"))
amount = Column(Float)
description = Column(Text)
fees = Column(Float)
net_to_seller = Column(Float)
status = Column(String(20), default="approved")
created_at = Column(DateTime, default=datetime.utcnow)

DB Setup (use env var for production)

ENGINE = create_engine("sqlite:///./modac.db") # Swap to Postgres URI
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=ENGINE)
Base.metadata.create_all(bind=ENGINE)

1. algorithm.py (Your Full Algorithm – Integrated) import hashlib import math from datetime import datetime from typing import Dict, List, Optional

class MODACAlgorithm:
def generate_agent_id(self, name: str, creator_email: str) -> str:
seed = f"{name.lower()}{creator_email.lower()}{datetime.utcnow():%Y-%m-%d}"
return "MODAC_" + hashlib.sha256(seed.encode()).hexdigest()[:12].upper()

def calculate_trust_score(self, agent: Dict) -> float:
    score = 50.0
    if agent.get("creator_verified", False):
        score += 15
    if "@gmail.com" not in agent.get("creator_email", "") and "@yahoo.com" not in agent.get("creator_email", ""):
        score += 5
    trusted_frameworks = ["LangChain", "CrewAI", "AutoGen", "LlamaIndex", "Haystack", "Semantic Kernel"]
    if agent.get("framework") in trusted_frameworks:
        score += 12
    created_at = agent["created_at"].replace("Z", "") if "Z" in str(agent["created_at"]) else str(agent["created_at"])
    days_since_register = (datetime.utcnow() - datetime.fromisoformat(created_at)).days
    if days_since_register > 30:
        score += 10
    if days_since_register > 90:
        score += 10
    github_stars = agent.get("github_stars", 0)
    score += min(github_stars // 10, 15)
    if agent.get("human_verified"):
        score += 18
    return min(100.0, max(0.0, score))

def calculate_ranking_score(self, agent: Dict, query: Optional[str] = None) -> float:
    base = self.calculate_trust_score(agent)
    boosts = 0.0
    if query:
        name_match = agent["name"].lower().count(query.lower())
        desc_match = agent["description"].lower().count(query.lower())
        boosts += (name_match * 15) + (desc_match * 8)
    created_at = agent["created_at"].replace("Z", "") if "Z" in str(agent["created_at"]) else str(agent["created_at"])
    hours_old = (datetime.utcnow() - datetime.fromisoformat(created_at)).total_seconds() / 3600
    if hours_old < 24:
        boosts += 20 * math.exp(-hours_old / 12)
    boosts += agent.get("monthly_calls", 0) / 100
    popularity = {"LangChain": 1.4, "CrewAI": 1.3, "AutoGen": 1.2}.get(agent.get("framework"), 1.0)
    boosts *= popularity
    return base + boosts

def should_feature_agent(self, agent: Dict) -> bool:
    return self.calculate_trust_score(agent) >= 85 and agent.get("monthly_calls", 0) > 500 or agent.get("featured_by_admin") == True

def is_spam(self, agent: Dict) -> bool:
    flags = 0
    name = agent["name"].lower()
    spam_keywords = ["earn money", "free bitcoin", "sex", "xxx", "casino", "lottery"]
    if any(word in name for word in spam_keywords):
        flags += 1
    if len(agent["name"]) < 5 or len(agent["description"]) < 20:
        flags += 1
    if "http" in agent["description"].lower():
        flags += 2
    return flags >= 2

def process_new_agent(self, data: Dict) -> Dict:
    if self.is_spam(data):
        return {"status": "rejected", "reason": "spam_detected"}
    agent_id = self.generate_agent_id(data["name"], data["creator_email"])
    agent = {
        "agent_id": agent_id,
        "name": data["name"],
        "description": data.get("description", ""),
        "creator_email": data["creator_email"],
        "framework": data.get("framework", "Unknown"),
        "tags": data.get("tags", []),
        "website": data.get("website", ""),
        "github": data.get("github", ""),
        "created_at": datetime.utcnow(),
        "trust_score": 50.0,
        "monthly_calls": 0,
        "human_verified": False,
        "featured": False,
        "status": "live"
    }
    agent["trust_score"] = self.calculate_trust_score(agent)
    agent["featured"] = self.should_feature_agent(agent)
    return {"status": "approved", "agent": agent, "message": f"Welcome! ID: {agent_id}"}

def rank_agents(self, agents: List[Dict], query: str = None) -> List[Dict]:
    for agent in agents:
        agent["ranking_score"] = self.calculate_ranking_score(agent, query)
    return sorted(agents, key=lambda x: x["ranking_score"], reverse=True)[:50]

1. main.py (FastAPI App) from fastapi import FastAPI, HTTPException, Depends from fastapi.middleware.cors import CORSMiddleware from pydantic import BaseModel from sqlalchemy.orm import Session from sqlalchemy import text from models import SessionLocal, Agent, Transaction from algorithm import MODACAlgorithm import stripe from dotenv import load_dotenv import os from typing import List

load_dotenv()
app = FastAPI(title="MODAC GLOBAL SYSTEM Backend")

app.add_middleware(
CORSMiddleware,
allow_origins=[""],
allow_credentials=True,
allow_methods=[""],
allow_headers=["*"],
)

algo = MODACAlgorithm()
stripe.api_key = os.getenv("STRIPE_SECRET_KEY") # Optional for fees

Dependency

def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()

class AgentCreate(BaseModel):
name: str
description: str
creator_email: str
framework: str = "LangChain"
tags: List[str] = []

class TransactionCreate(BaseModel):
buyer_agent_id: str
seller_agent_id: str
amount: float
description: str = ""

@app.post("/api/register")
def register_agent(agent_data: AgentCreate, db: Session = Depends(get_db)):
result = algo.process_new_agent(agent_data.dict())
if result["status"] == "rejected":
raise HTTPException(status_code=400, detail=result["reason"])
new_agent = Agent(**result["agent"])
db.add(new_agent)
db.commit()
db.refresh(new_agent)
return {"agent_id": new_agent.agent_id, "trust_score": new_agent.trust_score}

@app.get("/api/agents")
def list_agents(db: Session = Depends(get_db)):
agents = db.query(Agent).all()
return algo.rank_agents([a.dict for a in agents])

@app.post("/api/transactions")
def process_transaction(txn_data: TransactionCreate, db: Session = Depends(get_db)):
buyer = db.query(Agent).filter(Agent.agent_id == txn_data.buyer_agent_id).first()
seller = db.query(Agent).filter(Agent.agent_id == txn_data.seller_agent_id).first()
if not buyer or not seller or buyer.status != "live" or seller.status != "live":
raise HTTPException(status_code=400, detail="Invalid agents")
fee_percent = txn_data.amount * 0.03
fee_fixed = 20.0
total_fees = fee_percent + fee_fixed
net_to_seller = txn_data.amount - total_fees
txn_id = f"TXN_{uuid.uuid4().hex[:12].upper()}"
new_txn = Transaction(
txn_id=txn_id,
buyer_agent_id=txn_data.buyer_agent_id,
seller_agent_id=txn_data.seller_agent_id,
amount=txn_data.amount,
description=txn_data.description,
fees=total_fees,
net_to_seller=net_to_seller
)
db.add(new_txn)
db.commit()
# Update balances (stub – add Stripe capture here)
seller.monthly_calls += 1
db.commit()
return {"txn_id": txn_id, "fees": total_fees, "net_to_seller": net_to_seller}

if name == "main":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8000)

1. vercel.json (For Vercel Deployment) { "version": 2, "builds": [ { "src": "main.py", "use": "@vercel/python" } ], "routes": [ { "src": "/(.*)", "dest": "main.py" } ] }