| """AUBIN MCP sunucusu (stdio, bağımlılıksız JSON-RPC 2.0) — başka bir yapay zekâ AUBIN'i araç olarak çağırır. |
| |
| Araçlar: |
| decide(state, questions) → kalibre olasılıklar (tipli sorular) |
| act(observation, actions, command?) → anlık hamle + güven + gecikme (AubinController) |
| loop(task, numeric?) → üretici + karar döngüsü (AubinLoop, Gemma üretici) |
| |
| İstemci yapılandırması (ör. Claude Desktop / Claude Code): |
| {"mcpServers": {"aubin": {"command": "python", "args": ["-m", "aubin.mcp_server", "--model", "emrevrg/AUBIN-12B"]}}} |
| Model ilk araç çağrısında bir kez yüklenir; istekler sırayla işlenir (tek GPU). |
| """ |
| from __future__ import annotations |
| import argparse, json, sys, threading, traceback |
|
|
| PROTOCOL = "2025-06-18" |
| TOOLS = [ |
| {"name": "decide", "description": "Typed decision: state + questions (choice / noul / score) -> calibrated probabilities.", |
| "inputSchema": {"type": "object", "properties": {"state": {}, "questions": {"type": "object"}}, "required": ["state", "questions"]}}, |
| {"name": "act", "description": "Real-time control: observation + allowed actions {name: description} (+ optional command) " |
| "-> one action with confidence and latency. Low confidence falls back to 'fallback' if given.", |
| "inputSchema": {"type": "object", "properties": {"observation": {}, "actions": {"type": "object"}, "command": {"type": "string"}, |
| "min_conf": {"type": "number"}, "fallback": {"type": "string"}}, |
| "required": ["observation", "actions"]}}, |
| {"name": "loop", "description": "Generator + decider loop: candidates are generated, AUBIN picks with calibrated confidence, " |
| "regenerates when unsure.", |
| "inputSchema": {"type": "object", "properties": {"task": {"type": "string"}, "numeric": {"type": "boolean"}}, "required": ["task"]}}, |
| ] |
|
|
|
|
| class Server: |
| def __init__(self, model_spec, think): |
| self.spec, self.think, self.m, self.lock = model_spec, think, None, threading.Lock() |
|
|
| def model(self): |
| if self.m is None: |
| from .core import Aubin, AubinEnsemble |
| specs = [x.rsplit(":", 1) if ":" in x and not x.startswith("hf:") else (x, "1") for x in self.spec.split(",")] |
| ms = [(Aubin(r, think_margin=self.think), float(w)) for r, w in specs] |
| self.m = ms[0][0] if len(ms) == 1 else AubinEnsemble(ms) |
| return self.m |
|
|
| def call(self, name, args): |
| with self.lock: |
| m = self.model() |
| if name == "decide": |
| return m.decide(args["state"], args["questions"]) |
| if name == "act": |
| from .control import AubinController |
| ctl = AubinController(m, args["actions"], min_conf=args.get("min_conf", 0.0), fallback=args.get("fallback")) |
| return ctl.act(args["observation"], args.get("command")) |
| if name == "loop": |
| from .loop import AubinLoop, GemmaGenerator, last_number, final_line |
| base = m if hasattr(m, "tok") else m.members[0][0] |
| lp = AubinLoop(m, GemmaGenerator(base), extract=last_number if args.get("numeric") else final_line, mode="aubin+vote") |
| return lp.solve(args["task"]) |
| raise ValueError(f"bilinmeyen araç: {name}") |
|
|
| def handle(self, msg): |
| mid, meth, p = msg.get("id"), msg.get("method"), msg.get("params") or {} |
| if meth == "initialize": |
| return {"protocolVersion": p.get("protocolVersion", PROTOCOL), "capabilities": {"tools": {}}, |
| "serverInfo": {"name": "aubin", "version": "0.1.0"}} |
| if meth == "tools/list": |
| return {"tools": TOOLS} |
| if meth == "tools/call": |
| try: |
| out = self.call(p["name"], p.get("arguments") or {}) |
| return {"content": [{"type": "text", "text": json.dumps(out, ensure_ascii=False)}], "isError": False} |
| except Exception as e: |
| return {"content": [{"type": "text", "text": f"{type(e).__name__}: {e}"}], "isError": True} |
| if meth == "ping": |
| return {} |
| if mid is None: |
| return None |
| raise KeyError(meth) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser(prog="aubin-mcp") |
| ap.add_argument("--model", default="emrevrg/AUBIN-12B"); ap.add_argument("--think", type=float, default=None) |
| a = ap.parse_args() |
| S = Server(a.model, a.think) |
| for line in sys.stdin: |
| line = line.strip() |
| if not line: |
| continue |
| try: |
| msg = json.loads(line) |
| except json.JSONDecodeError: |
| continue |
| try: |
| res = S.handle(msg) |
| if msg.get("id") is None: |
| continue |
| reply = {"jsonrpc": "2.0", "id": msg["id"], "result": res} |
| except KeyError as e: |
| reply = {"jsonrpc": "2.0", "id": msg.get("id"), "error": {"code": -32601, "message": f"method not found: {e}"}} |
| except Exception as e: |
| print(traceback.format_exc(), file=sys.stderr) |
| reply = {"jsonrpc": "2.0", "id": msg.get("id"), "error": {"code": -32603, "message": str(e)}} |
| sys.stdout.write(json.dumps(reply, ensure_ascii=False) + "\n"); sys.stdout.flush() |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
