Upload 2 files

app.py

@@ -0,0 +1,267 @@
+
+import os, json, time, sqlite3, requests, io, csv
+import numpy as np
+import gradio as gr
+from typing import List, Dict
+from sentence_transformers import SentenceTransformer
+
+# ---- DAO CONFIG ----
+DAO_ADDRESS = os.environ.get("DAO_ADDRESS", "0xE2F60eEEd806Cb2790c0685334D0b95417c386E0")
+FIELD_TOKEN = os.environ.get("FIELD_TOKEN", "")
+ARBITRUM_RPC = os.environ.get("ARBITRUM_RPC", "https://arb1.arbitrum.io/rpc")
+
+TELEMETRY_WEBHOOK = os.environ.get("TELEMETRY_WEBHOOK", "")  # point to FastAPI server /usage
+PREMIUM_KEY = os.environ.get("PREMIUM_KEY", "")
+FREE_LIMIT = int(os.environ.get("FREE_LIMIT", "20"))
+
+DB_PATH = os.environ.get("DB_PATH", "inneri_reskill.db")
+EMBED_MODEL = os.environ.get("EMBED_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
+TOP_K = int(os.environ.get("TOP_K", "5"))
+
+def db():
+    conn = sqlite3.connect(DB_PATH)
+    conn.execute("PRAGMA foreign_keys = ON;")
+    return conn
+
+def init_db():
+    conn = db(); cur = conn.cursor()
+    cur.execute("CREATE TABLE IF NOT EXISTS users(user_id TEXT PRIMARY KEY, balance_cents INTEGER DEFAULT 0);")
+    cur.execute("CREATE TABLE IF NOT EXISTS guides(id INTEGER PRIMARY KEY AUTOINCREMENT, owner_id TEXT, title TEXT, text TEXT, tags TEXT, namespace TEXT, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP);")
+    cur.execute("CREATE TABLE IF NOT EXISTS embeds(id INTEGER PRIMARY KEY AUTOINCREMENT, guide_id INTEGER, namespace TEXT, dim INTEGER, vec BLOB, FOREIGN KEY(guide_id) REFERENCES guides(id) ON DELETE CASCADE);")
+    cur.execute("CREATE TABLE IF NOT EXISTS traces(id INTEGER PRIMARY KEY AUTOINCREMENT, trace_id TEXT, user_id TEXT, question TEXT, answer TEXT, sources TEXT, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP);")
+    cur.execute("CREATE TABLE IF NOT EXISTS usage_credits(user_id TEXT, guide_id INTEGER, credits REAL, period TEXT);")
+    conn.commit(); conn.close()
+
+def ensure_user(user_id:str):
+    conn = db(); cur = conn.cursor()
+    cur.execute("INSERT OR IGNORE INTO users(user_id,balance_cents) VALUES(?,0)", (user_id,))
+    conn.commit(); conn.close()
+
+_embedder = None
+def get_embedder():
+    global _embedder
+    if _embedder is None:
+        _embedder = SentenceTransformer(EMBED_MODEL)
+    return _embedder
+
+def embed_texts(texts: List[str]):
+    return np.array(get_embedder().encode(texts, show_progress_bar=False, normalize_embeddings=True), dtype=np.float32)
+
+def vec_to_blob(vec: np.ndarray) -> bytes:
+    return vec.astype(np.float32).tobytes()
+
+def blob_to_vec(blob: bytes) -> np.ndarray:
+    return np.frombuffer(blob, dtype=np.float32)
+
+def add_guide(owner_id:str, title:str, text:str, tags:str, namespace:str):
+    ensure_user(owner_id)
+    conn = db(); cur = conn.cursor()
+    cur.execute("INSERT INTO guides(owner_id,title,text,tags,namespace) VALUES(?,?,?,?,?)",(owner_id, title, text, tags, namespace))
+    gid = cur.lastrowid
+    vec = embed_texts([text])[0]
+    cur.execute("INSERT INTO embeds(guide_id,namespace,dim,vec) VALUES(?,?,?,?)",(gid, namespace, vec.shape[0], vec_to_blob(vec)))
+    conn.commit(); conn.close()
+    return gid
+
+def list_guides(namespace:str):
+    conn = db(); cur = conn.cursor()
+    cur.execute("SELECT id, owner_id, title, tags, created_at FROM guides WHERE namespace=? ORDER BY created_at DESC",(namespace,))
+    rows = cur.fetchall(); conn.close()
+    return rows
+
+def retrieve(question:str, namespace:str, top_k:int=TOP_K)->List[Dict]:
+    qv = embed_texts([question])[0]
+    conn = db(); cur = conn.cursor()
+    cur.execute("SELECT e.id, e.guide_id, e.vec, g.title, g.owner_id, g.text FROM embeds e JOIN guides g ON e.guide_id=g.id WHERE e.namespace=?",(namespace,))
+    rows = cur.fetchall(); conn.close()
+    if not rows: return []
+    mat = np.stack([blob_to_vec(r[2]) for r in rows])
+    sims = mat @ qv
+    idx = np.argsort(-sims)[:top_k]
+    results = []
+    for i in idx:
+        _, gid, _, title, owner, text = rows[int(i)]
+        results.append({"guide_id": int(gid), "owner": owner, "title": title or "Untitled", "text": text, "score": float(sims[int(i)])})
+    return results
+
+def synthesize_answer(question:str, contexts:List[Dict])->str:
+    bullets = []
+    for i,c in enumerate(contexts):
+        snippet = c["text"][:400].replace("\n"," ").strip()
+        bullets.append(f"[{i+1}] {c['title']}: {snippet}")
+    return "Q: " + question + "\n\nGuides:\n" + "\n".join(bullets)
+
+def record_usage(ctx:List[Dict], period:str):
+    conn = db(); cur = conn.cursor()
+    total = sum(max(0.0, c["score"]) for c in ctx) or 1.0
+    for c in ctx:
+        w = max(0.0, c["score"])/total
+        cur.execute("INSERT INTO usage_credits(user_id, guide_id, credits, period) VALUES(?,?,?,?)",
+                    (c["owner"], c["guide_id"], w, period))
+    conn.commit(); conn.close()
+
+def payout_csv(period:str, total_field:int=50000):
+    conn = db(); cur = conn.cursor()
+    cur.execute("SELECT user_id, SUM(credits) FROM usage_credits WHERE period=? GROUP BY user_id", (period,))
+    rows = cur.fetchall(); conn.close()
+    total = sum(r[1] for r in rows) or 1.0
+    lines = ["recipient_address,amount_FIELD,reason,period"]
+    for user, credits in rows:
+        amt = int(round(total_field * (credits/total)))
+        lines.append(f"{user},{amt},Guide usage,{period}")
+    return "\n".join(lines)
+
+def dao_panel_read(field_token:str):
+    out = {"dao_address": DAO_ADDRESS, "field_token": field_token or "(set FIELD_TOKEN)", "balances": {}, "notes": ""}
+    try:
+        from web3 import Web3
+        ERC20_ABI = [
+            {"constant":True,"inputs":[{"name":"a","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"type":"function"},
+            {"constant":True,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"type":"function"},
+            {"constant":True,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"type":"function"},
+            {"constant":True,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"type":"function"}
+        ]
+        w3 = Web3(Web3.HTTPProvider(ARBITRUM_RPC, request_kwargs={"timeout": 10}))
+        if not field_token:
+            out["notes"] = "Set FIELD_TOKEN to read balances."
+            return json.dumps(out, indent=2)
+        token = w3.eth.contract(address=w3.to_checksum_address(field_token), abi=ERC20_ABI)
+        dec = token.functions.decimals().call()
+        sym = token.functions.symbol().call()
+        ts  = token.functions.totalSupply().call() / (10**dec)
+        bal = token.functions.balanceOf(w3.to_checksum_address(DAO_ADDRESS)).call() / (10**dec)
+        out["balances"] = {"symbol": sym, "decimals": dec, "total_supply": ts, "dao_balance": bal}
+    except Exception as e:
+        out["notes"] = f"RPC/ABI error: {e}"
+    return json.dumps(out, indent=2)
+
+def generate_actions_from_csv(csv_text:str, token_address:str, decimals:int=18):
+    try:
+        from web3 import Web3
+        from eth_abi import encode as abi_encode
+    except Exception as e:
+        return "Missing dependency: web3/eth_abi. Ensure requirements are installed."
+    rows = list(csv.reader(io.StringIO(csv_text.strip())))
+    header = [h.strip().lower() for h in rows[0]]
+    if header[:2] != ["recipient_address","amount_field"]:
+        return "CSV must start with columns: recipient_address,amount_FIELD,..."
+    actions = []
+    selector = Web3.keccak(text="transfer(address,uint256)")[:4]
+    w3 = Web3()
+    for r in rows[1:]:
+        if not r or len(r)<2: 
+            continue
+        to = w3.to_checksum_address(r[0].strip())
+        amt = int(r[1].strip())
+        wei = amt * (10**decimals)
+        data = "0x" + (selector + abi_encode(["address","uint256"], [to, wei])).hex()
+        actions.append({"to": token_address, "value": 0, "data": data})
+    return json.dumps(actions, indent=2)
+
+SESSION_QUERIES = {}
+def log(evt, payload):
+    try:
+        if TELEMETRY_WEBHOOK:
+            requests.post(TELEMETRY_WEBHOOK, json={"evt":evt, **payload}, timeout=5)
+    except Exception:
+        pass
+
+def ask(user_id:str, question:str, namespace:str, premium_key:str, period:str):
+    sid = user_id or "anon"
+    count = SESSION_QUERIES.get(sid, 0)
+    if (not PREMIUM_KEY) or (premium_key != PREMIUM_KEY):
+        if count >= FREE_LIMIT:
+            return f"Free limit reached ({FREE_LIMIT}). Enter premium key.", "", ""
+    SESSION_QUERIES[sid] = count + 1
+
+    ctx = retrieve(question, namespace)
+    if not ctx:
+        return "No guides yet. Add some first.", "", ""
+    ans = synthesize_answer(question, ctx)
+    record_usage(ctx, period)
+    log("ask", {"user": sid, "ns": namespace, "period": period, "guide_ids": [c["guide_id"] for c in ctx]})
+    src = "\n".join([f"[{i+1}] {c['title']} (id {c['guide_id']}) {c['score']:.2f}" for i,c in enumerate(ctx)])
+    return ans, src, str(int(time.time()*1000))
+
+SEED_NAMESPACE = "inneri-guides"
+SEED_GUIDES = [
+("seed","Prompt Clarity: 3 Moves","1) State the goal clearly.\n2) Add 1–3 constraints.\n3) Give a short example.","prompt,basics"),
+("seed","RAG Basics: Store & Retrieve","Chunk docs, embed, retrieve, generate with citations.","rag,basics"),
+("seed","Chunking That Works","Overlap 50–100 tokens, respect headings, avoid >1k tokens.","rag,chunking"),
+("seed","Choosing Embedding Models","MiniLM for speed; e5/bge for quality; normalize; version.","embeddings,models"),
+("seed","Eval Signals","Score faithfulness, relevance, actionability.","evals,quality"),
+("seed","Langfuse Setup","Log routes, latency; attach evals; dashboard triage.","observability,langfuse"),
+("seed","Agentic Loops","Plan → Act → Observe → Reflect; timeouts; state; kill switch.","agents,loops"),
+("seed","FastAPI for AI","/chat, /embed, /query; rate limit; metrics; costs.","ops,api"),
+("seed","Data Rights & Payouts","Creators own docs; track usage; split fees.","legal,economics"),
+("seed","Safety & Scope","Refuse dangerous asks; stay in domain; red-team.","safety,policy"),
+]
+
+def seed_if_empty():
+    conn = db(); cur = conn.cursor()
+    cur.execute("SELECT COUNT(*) FROM guides WHERE namespace=?",(SEED_NAMESPACE,))
+    if cur.fetchone()[0]==0:
+        for o,t,tx,tg in SEED_GUIDES:
+            add_guide(o,t,tx,tg,SEED_NAMESPACE)
+
+init_db(); seed_if_empty()
+
+with gr.Blocks(title="Reskill the Field — Inner I Agentic AI (DAO-Wired)") as demo:
+    gr.Markdown(f"### Reskill the Field DAO — Inner I Agentic AI\nDAO: **{DAO_ADDRESS}** (Arbitrum) | Library + RAG + Payouts + Proposal Generator")
+
+    with gr.Tab("DAO Panel"):
+        token_in = gr.Textbox(label="$FIELD Token Address (ERC-20)", value=FIELD_TOKEN)
+        read_btn = gr.Button("Read DAO Balances")
+        read_out = gr.Textbox(label="DAO Balances (JSON)", lines=10)
+        read_btn.click(lambda t: dao_panel_read(t), [token_in], [read_out])
+        gr.Markdown("Treasury note: target **1,000,000 $FIELD** held. Set `FIELD_TOKEN` to verify on-chain.")
+
+    with gr.Tab("Browse Guides"):
+        ns = gr.Textbox(label="Namespace", value=SEED_NAMESPACE)
+        list_btn = gr.Button("List")
+        table = gr.Dataframe(headers=["id","owner","title","tags","created"], datatype=["number","str","str","str","str"])
+        def _list(namespace): return [[r[0],r[1],r[2],r[3],r[4]] for r in list_guides(namespace)]
+        list_btn.click(_list,[ns],[table])
+
+    with gr.Tab("Add Guide"):
+        u = gr.Textbox(label="Your Handle (wallet address preferred for payouts)", value="0xYourWallet")
+        title = gr.Textbox(label="Title", value="My New Guide")
+        tags = gr.Textbox(label="Tags", value="custom")
+        ns2 = gr.Textbox(label="Namespace", value=SEED_NAMESPACE)
+        txt = gr.Textbox(label="Guide Text", lines=10)
+        add_btn = gr.Button("Add Guide")
+        add_out = gr.Textbox(label="Result")
+        def _add(uid,title,text,tags,ns):
+            if not text.strip(): return "Add some text."
+            gid=add_guide(uid,title,text,tags,ns); return f"Added id={gid}"
+        add_btn.click(_add,[u,title,txt,tags,ns2],[add_out])
+
+    with gr.Tab("Ask (RAG) + Usage Log"):
+        u2=gr.Textbox(label="User ID (optional)", value="")
+        q=gr.Textbox(label="Question", value="How do I set up eval signals?", lines=3)
+        ns3=gr.Textbox(label="Namespace", value=SEED_NAMESPACE)
+        period=gr.Textbox(label="Period (YYYY-MM)", value="2025-09")
+        prem=gr.Textbox(label="Premium Key (optional)", value="")
+        ask_btn=gr.Button("Ask")
+        ans=gr.Textbox(label="Answer", lines=12)
+        src=gr.Textbox(label="Sources", lines=8)
+        trace=gr.Textbox(label="Trace ID")
+        ask_btn.click(lambda uid,qq,ns,per,pk: ask(uid,qq,ns,pk,per), [u2,q,ns3,period,prem],[ans,src,trace])
+
+    with gr.Tab("Payout Builder (CSV)"):
+        per=gr.Textbox(label="Period (YYYY-MM)", value="2025-09")
+        total=gr.Number(label="Total $FIELD to distribute", value=50000, precision=0)
+        build=gr.Button("Generate CSV")
+        csv_out=gr.Textbox(label="CSV Preview", lines=12)
+        build.click(lambda p,t: payout_csv(p, int(t)), [per,total],[csv_out])
+
+    with gr.Tab("Proposal Generator (Aragon Actions)"):
+        gr.Markdown("Paste payout CSV → get ERC-20 `transfer()` actions JSON for Aragon's Custom action.")
+        csv_in = gr.Textbox(label="Payout CSV", lines=12, value="recipient_address,amount_FIELD,reason,period\n0x0000000000000000000000000000000000000000,1000,Guide usage,2025-09")
+        token_addr = gr.Textbox(label="$FIELD Token Address", value=FIELD_TOKEN)
+        decimals = gr.Number(label="Token Decimals", value=18, precision=0)
+        gen_btn = gr.Button("Generate Actions JSON")
+        actions_out = gr.Textbox(label="Encoded Actions JSON", lines=14)
+        gen_btn.click(lambda c,t,d: generate_actions_from_csv(c,t,int(d)), [csv_in, token_addr, decimals], [actions_out])
+
+demo.launch()

requirements.txt

@@ -0,0 +1,7 @@
+
+gradio==4.36.1
+sentence-transformers==2.7.0
+numpy==1.26.4
+requests==2.32.3
+web3==6.19.0
+eth-abi==5.1.0