Download projects/oui-max/scripts/tools_server.py from LevelUp2x/adaptai: direct link, hf CLI and curl.
- Browser
- Download file 13.5 kB
-
https://huggingface.co/datasets/LevelUp2x/adaptai/resolve/main/projects/oui-max/scripts/tools_server.py
- Command line
-
hf download hf://datasets/LevelUp2x/adaptai/projects/oui-max/scripts/tools_server.py
-
curl -L -o tools_server.py https://huggingface.co/datasets/LevelUp2x/adaptai/resolve/main/projects/oui-max/scripts/tools_server.py
13.5 kB
| #!/usr/bin/env python3 | |
| from fastapi import FastAPI | |
| from pydantic import BaseModel, Field | |
| from typing import List, Optional, Dict, Any | |
| import os, json | |
| import requests | |
| import base64 | |
| import threading | |
| app = FastAPI(title="Nova Tools Server", version="0.1.0") | |
| # Feature Flags (controlled by environment variables) | |
| ENABLE_NATS = os.getenv("ENABLE_NATS", "1") == "1" | |
| ENABLE_QDRANT = os.getenv("ENABLE_QDRANT", "1") == "1" | |
| ENABLE_REDIS = os.getenv("ENABLE_REDIS", "1") == "1" | |
| ENABLE_EMBED = os.getenv("ENABLE_EMBED", "1") == "1" | |
| ENABLE_BROWSER = os.getenv("ENABLE_BROWSER", "1") == "1" | |
| # --------- Models --------- | |
| class BusPublishBody(BaseModel): | |
| subject: str | |
| message: str | |
| url: Optional[str] = None | |
| class KVBody(BaseModel): | |
| key: str | |
| value: Optional[str] = None | |
| host: str = Field(default="127.0.0.1") | |
| port: int = Field(default=18010) # Changed from 18000 to 18010 | |
| class QdrantEnsureBody(BaseModel): | |
| collection: str | |
| size: int | |
| distance: str = Field(default="Cosine") | |
| url: str = Field(default_factory=lambda: os.getenv("QDRANT_URL", "http://127.0.0.1:17000")) | |
| class QdrantUpsertBody(BaseModel): | |
| collection: str | |
| points: List[Dict[str, Any]] | |
| url: str = Field(default_factory=lambda: os.getenv("QDRANT_URL", "http://127.0.0.1:17000")) | |
| class QdrantQueryBody(BaseModel): | |
| collection: str | |
| vector: List[float] | |
| top: int = 5 | |
| url: str = Field(default_factory=lambda: os.getenv("QDRANT_URL", "http://127.0.0.1:17000")) | |
| class EmbedBody(BaseModel): | |
| texts: List[str] | |
| model: str = Field(default_factory=lambda: os.getenv("EMBED_MODEL", "BAAI/bge-m3")) | |
| api_base: str = Field(default_factory=lambda: os.getenv("EMBED_API_BASE", "http://127.0.0.1:17592/v1")) | |
| local: bool = Field(default_factory=lambda: os.getenv("EMBED_LOCAL", "0") == "1") | |
| # --------- Endpoints --------- | |
| if ENABLE_NATS: | |
| def bus_publish(body: BusPublishBody): | |
| import asyncio | |
| try: | |
| import nats # type: ignore | |
| except Exception as e: | |
| return {"ok": False, "error": f"nats-py not installed: {e}"} | |
| async def _run(): | |
| url = body.url or os.getenv("NATS_URL", "nats://127.0.0.1:18222") | |
| nc = await nats.connect(url) | |
| await nc.publish(body.subject, body.message.encode("utf-8")) | |
| await nc.flush() | |
| await nc.close() | |
| return {"ok": True} | |
| return asyncio.run(_run()) | |
| if ENABLE_REDIS: | |
| def kv_set(body: KVBody): | |
| try: | |
| import redis # type: ignore | |
| except Exception as e: | |
| return {"ok": False, "error": f"redis not installed: {e}"} | |
| try: | |
| r = redis.Redis(host=body.host, port=body.port, decode_responses=True) | |
| r.set(body.key, body.value or "") | |
| return {"ok": True} | |
| except Exception as e: | |
| return {"ok": False, "error": str(e)} | |
| def kv_get(body: KVBody): | |
| try: | |
| import redis # type: ignore | |
| except Exception as e: | |
| return {"ok": False, "error": f"redis not installed: {e}"} | |
| try: | |
| r = redis.Redis(host=body.host, port=body.port, decode_responses=True) | |
| v = r.get(body.key) | |
| return {"ok": True, "value": v} | |
| except Exception as e: | |
| return {"ok": False, "error": str(e)} | |
| def kv_delete(body: KVBody): | |
| try: | |
| import redis # type: ignore | |
| except Exception as e: | |
| return {"ok": False, "error": f"redis not installed: {e}"} | |
| try: | |
| r = redis.Redis(host=body.host, port=body.port, decode_responses=True) | |
| r.delete(body.key) | |
| return {"ok": True} | |
| except Exception as e: | |
| return {"ok": False, "error": str(e)} | |
| if ENABLE_QDRANT: | |
| def qdrant_ensure(body: QdrantEnsureBody): | |
| payload = {"vectors": {"size": body.size, "distance": body.distance}, "optimizers_config": {"default_segment_number": 1}} | |
| r = requests.put(f"{body.url}/collections/{body.collection}", json=payload, timeout=10) | |
| return {"status": r.status_code, "data": r.json() if r.content else None} | |
| def qdrant_upsert(body: QdrantUpsertBody): | |
| r = requests.put(f"{body.url}/collections/{body.collection}/points", params={"wait": "true"}, json={"points": body.points}, timeout=15) | |
| return {"status": r.status_code, "data": r.json() if r.content else None} | |
| def qdrant_query(body: QdrantQueryBody): | |
| r = requests.post(f"{body.url}/collections/{body.collection}/points/search", json={"vector": body.vector, "limit": body.top}, timeout=10) | |
| return {"status": r.status_code, "data": r.json() if r.content else None} | |
| # Note: The /embed endpoint may fail due to permission issues when downloading models. | |
| # This is a host system configuration issue and cannot be fixed by the tools server. | |
| if ENABLE_EMBED: | |
| def embed(body: EmbedBody): | |
| if not body.local: | |
| url = f"{body.api_base}/embeddings" | |
| req = {"model": body.model, "input": body.texts} | |
| try: | |
| resp = requests.post(url, json=req, timeout=30) | |
| j = resp.json() | |
| if resp.status_code == 200 and "data" in j: | |
| vecs = [d.get("embedding") for d in j["data"]] | |
| return {"ok": True, "embeddings": vecs} | |
| # fallthrough to local if API not ready | |
| except Exception: | |
| pass | |
| # Local fallback via sentence-transformers | |
| try: | |
| from sentence_transformers import SentenceTransformer | |
| device = os.getenv("EMBED_DEVICE", "cpu") | |
| model = SentenceTransformer(body.model, device=device) | |
| vecs = model.encode(body.texts, normalize_embeddings=True).tolist() | |
| return {"ok": True, "embeddings": vecs} | |
| except Exception as e: | |
| return {"ok": False, "error": f"local embed failed: {e}"} | |
| class MemoryUpsertBody(BaseModel): | |
| collection: str | |
| items: List[Dict[str, Any]] # each: {id: str, text: str, payload: {...}} | |
| model: str = Field(default_factory=lambda: os.getenv("EMBED_MODEL", "BAAI/bge-m3")) | |
| url: str = Field(default_factory=lambda: os.getenv("QDRANT_URL", "http://127.0.0.1:17000")) | |
| local: bool = Field(default_factory=lambda: os.getenv("EMBED_LOCAL", "1") == "1") | |
| def memory_upsert_text(body: MemoryUpsertBody): | |
| texts = [it.get("text", "") for it in body.items] | |
| emb_res = embed(EmbedBody(texts=texts, model=body.model, api_base=os.getenv("EMBED_API_BASE", "http://127.0.0.1:17592/v1"), local=body.local)) | |
| if not emb_res.get("ok"): | |
| return {"ok": False, "error": emb_res.get("error")} | |
| vecs = emb_res.get("embeddings", []) | |
| points = [] | |
| for it, v in zip(body.items, vecs): | |
| points.append({"id": it.get("id"), "vector": v, "payload": it.get("payload", {})}) | |
| up = requests.put(f"{body.url}/collections/{body.collection}/points", params={"wait": "true"}, json={"points": points}, timeout=15) | |
| try: | |
| data = up.json() | |
| except Exception: | |
| data = None | |
| return {"ok": up.status_code == 200, "status": up.status_code, "data": data} | |
| class MemorySearchBody(BaseModel): | |
| collection: str | |
| text: str | |
| top: int = 5 | |
| model: str = Field(default_factory=lambda: os.getenv("EMBED_MODEL", "BAAI/bge-m3")) | |
| url: str = Field(default_factory=lambda: os.getenv("QDRANT_URL", "http://127.0.0.1:17000")) | |
| local: bool = Field(default_factory=lambda: os.getenv("EMBED_LOCAL", "1") == "1") | |
| def memory_search_text(body: MemorySearchBody): | |
| """ | |
| Embed the input text and perform a nearest-neighbor search in Qdrant. | |
| Returns the raw Qdrant response including payloads when available. | |
| """ | |
| # Get embedding for the query text | |
| emb_res = embed(EmbedBody(texts=[body.text], model=body.model, api_base=os.getenv("EMBED_API_BASE", "http://127.0.0.1:17592/v1"), local=body.local)) | |
| if not emb_res.get("ok"): | |
| return {"ok": False, "error": emb_res.get("error", "embed failed")} | |
| vecs = emb_res.get("embeddings", []) | |
| if not vecs: | |
| return {"ok": False, "error": "no embedding produced"} | |
| vector = vecs[0] | |
| # Perform search against Qdrant | |
| try: | |
| resp = requests.post( | |
| f"{body.url}/collections/{body.collection}/points/search", | |
| json={"vector": vector, "limit": body.top, "with_payload": True, "with_vectors": False}, | |
| timeout=15, | |
| ) | |
| data = resp.json() if resp.content else None | |
| return {"ok": resp.status_code == 200, "status": resp.status_code, "data": data} | |
| except Exception as e: | |
| return {"ok": False, "error": str(e)} | |
| if ENABLE_BROWSER: | |
| # --------------- Playwright MCP-like endpoints --------------- | |
| _BROWSER_LOCK = threading.Lock() | |
| _SESSIONS: Dict[str, Dict[str, Any]] = {} | |
| class BrowserStartBody(BaseModel): | |
| headless: bool = True | |
| slow_mo_ms: int = 0 | |
| class BrowserSession(BaseModel): | |
| session_id: str | |
| def browser_start(body: BrowserStartBody): | |
| try: | |
| from playwright.sync_api import sync_playwright # type: ignore | |
| except Exception as e: | |
| return {"session_id": "", "error": f"playwright not installed: {e}"} | |
| with _BROWSER_LOCK: | |
| p = sync_playwright().start() | |
| browser = p.chromium.launch(headless=body.headless, slow_mo=body.slow_mo_ms or 0) | |
| context = browser.new_context() | |
| page = context.new_page() | |
| sid = f"sess_{len(_SESSIONS)+1}" | |
| _SESSIONS[sid] = {"p": p, "browser": browser, "context": context, "page": page} | |
| return {"session_id": sid} | |
| class BrowserNavBody(BaseModel): | |
| session_id: str | |
| url: str | |
| wait_selector: Optional[str] = None | |
| timeout_ms: int = 10000 | |
| def browser_goto(body: BrowserNavBody): | |
| s = _SESSIONS.get(body.session_id) | |
| if not s: | |
| return {"ok": False, "error": "invalid session"} | |
| page = s["page"] | |
| page.goto(body.url, timeout=body.timeout_ms) | |
| if body.wait_selector: | |
| page.wait_for_selector(body.wait_selector, timeout=body.timeout_ms) | |
| return {"ok": True, "url": page.url} | |
| class BrowserQueryBody(BaseModel): | |
| session_id: str | |
| selector: str | |
| attr: Optional[str] = None | |
| all: bool = True | |
| timeout_ms: int = 5000 | |
| def browser_query(body: BrowserQueryBody): | |
| s = _SESSIONS.get(body.session_id) | |
| if not s: | |
| return {"ok": False, "error": "invalid session"} | |
| page = s["page"] | |
| page.wait_for_selector(body.selector, timeout=body.timeout_ms) | |
| if body.all: | |
| els = page.query_selector_all(body.selector) | |
| else: | |
| el = page.query_selector(body.selector) | |
| els = [el] if el else [] | |
| out = [] | |
| for el in els: | |
| if not el: | |
| continue | |
| if body.attr: | |
| out.append(el.get_attribute(body.attr)) | |
| else: | |
| try: | |
| out.append(el.inner_text()) | |
| except Exception: | |
| out.append(el.text_content()) | |
| return {"ok": True, "values": out} | |
| class BrowserClickBody(BaseModel): | |
| session_id: str | |
| selector: str | |
| timeout_ms: int = 5000 | |
| def browser_click(body: BrowserClickBody): | |
| s = _SESSIONS.get(body.session_id) | |
| if not s: | |
| return {"ok": False, "error": "invalid session"} | |
| page = s["page"] | |
| page.wait_for_selector(body.selector, timeout=body.timeout_ms) | |
| page.click(body.selector, timeout=body.timeout_ms) | |
| return {"ok": True} | |
| class BrowserScreenshotBody(BaseModel): | |
| session_id: str | |
| full_page: bool = False | |
| def browser_screenshot(body: BrowserScreenshotBody): | |
| s = _SESSIONS.get(body.session_id) | |
| if not s: | |
| return {"ok": False, "error": "invalid session"} | |
| page = s["page"] | |
| buf = page.screenshot(full_page=body.full_page) | |
| b64 = base64.b64encode(buf).decode("ascii") | |
| return {"ok": True, "image_base64": b64} | |
| class BrowserCloseBody(BaseModel): | |
| session_id: str | |
| def browser_close(body: BrowserCloseBody): | |
| s = _SESSIONS.pop(body.session_id, None) | |
| if not s: | |
| return {"ok": True} | |
| try: | |
| s["browser"].close() | |
| except Exception: | |
| pass | |
| try: | |
| s["p"].stop() | |
| except Exception: | |
| pass | |
| return {"ok": True} | |
| if __name__ == "__main__": | |
| import uvicorn | |
| port = int(os.getenv("TOOLS_SERVER_PORT", "18190")) | |
| uvicorn.run(app, host="127.0.0.1", port=port) |