axeon-atrest 0.1.0__tar.gz

axeon_atrest-0.1.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: axeon-atrest
+Version: 0.1.0
+Summary: Agent Task Runtime & State Transport — middleware for AI agent communication, memory, and task lifecycle
+License-Expression: MIT
+Keywords: ai,agents,multi-agent,orchestration,middleware,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: redis>=5.0
+Requires-Dist: neo4j>=5.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: pydantic>=2.0
+Provides-Extra: api
+Requires-Dist: fastapi>=0.100; extra == "api"
+Requires-Dist: uvicorn>=0.22; extra == "api"
+Provides-Extra: all
+Requires-Dist: fastapi>=0.100; extra == "all"
+Requires-Dist: uvicorn>=0.22; extra == "all"
+
+# AT Rest — Agent Task Runtime & State Transport
+
+Middleware untuk agent communication, memory, dan task lifecycle.
+
+4 agent built-in (planner, researcher, reviewer, mentor) via Redis Streams bus.
+Neo4j task persistence. FastAPI REST API server. Qdrant + Neo4j knowledge retrieval.
+
+## Quick Start
+
+```bash
+pip install atrest
+```
+
+```python
+from atrest import Agent, generate, search
+
+class MyAgent(Agent):
+    channel = "researcher"
+
+    def handle_request(self, msg):
+        goal = msg["payload"]["goal"]
+        results = search(goal, limit=3)
+        summary = generate(f"Summarize: {goal}\n\nContext: {results}")
+        return {"summary": summary, "sources": []}
+
+MyAgent().run()
+```
+
+## Available Imports
+
+```python
+from atrest import Agent, ATRestClient, AgentBus, TaskStore, generate, embed, search
+```
+
+- `Agent` — base class for custom agents
+- `ATRestClient` — HTTP client for AT Rest API
+- `AgentBus` — Redis Streams pub/sub
+- `TaskStore` — Neo4j AgentTask persistence
+- `generate()` — Ollama LLM call
+- `embed()` — Ollama embedding
+- `search()` — Qdrant vector search
+
+## Optional: API Server
+
+```bash
+pip install atrest[api]
+python -m api.server
+```
+
+## Architecture
+
+```
+User → REST API / Agent SDK → Agent Bus (Redis Streams)
+  → Planner → Researcher / Reviewer / Mentor
+  → Task Store (Neo4j) → Broadcast
+  → Knowledge (Qdrant + Neo4j)
+```
+
+## License
+
+MIT

axeon_atrest-0.1.0/README.md

@@ -0,0 +1,61 @@
+# AT Rest — Agent Task Runtime & State Transport
+
+Middleware untuk agent communication, memory, dan task lifecycle.
+
+4 agent built-in (planner, researcher, reviewer, mentor) via Redis Streams bus.
+Neo4j task persistence. FastAPI REST API server. Qdrant + Neo4j knowledge retrieval.
+
+## Quick Start
+
+```bash
+pip install atrest
+```
+
+```python
+from atrest import Agent, generate, search
+
+class MyAgent(Agent):
+    channel = "researcher"
+
+    def handle_request(self, msg):
+        goal = msg["payload"]["goal"]
+        results = search(goal, limit=3)
+        summary = generate(f"Summarize: {goal}\n\nContext: {results}")
+        return {"summary": summary, "sources": []}
+
+MyAgent().run()
+```
+
+## Available Imports
+
+```python
+from atrest import Agent, ATRestClient, AgentBus, TaskStore, generate, embed, search
+```
+
+- `Agent` — base class for custom agents
+- `ATRestClient` — HTTP client for AT Rest API
+- `AgentBus` — Redis Streams pub/sub
+- `TaskStore` — Neo4j AgentTask persistence
+- `generate()` — Ollama LLM call
+- `embed()` — Ollama embedding
+- `search()` — Qdrant vector search
+
+## Optional: API Server
+
+```bash
+pip install atrest[api]
+python -m api.server
+```
+
+## Architecture
+
+```
+User → REST API / Agent SDK → Agent Bus (Redis Streams)
+  → Planner → Researcher / Reviewer / Mentor
+  → Task Store (Neo4j) → Broadcast
+  → Knowledge (Qdrant + Neo4j)
+```
+
+## License
+
+MIT

axeon_atrest-0.1.0/atrest/__init__.py

@@ -0,0 +1,6 @@
+from atrest.agent import Agent
+from atrest.client import ATRestClient
+from atrest.bus import AgentBus
+from atrest.task_store import TaskStore
+from atrest.llm import generate, embed
+from atrest.qdrant import search

axeon_atrest-0.1.0/atrest/agent.py

@@ -0,0 +1,68 @@
+"""AT Rest — Base Agent class. Extend to create custom agents."""
+import uuid
+from datetime import datetime, timezone
+
+from atrest.bus import AgentBus
+from atrest.task_store import TaskStore
+from shared.agent_memory import log_finding, log_decision
+
+class Agent:
+    """Base class for AT Rest agents.
+
+    Usage:
+        class MyAgent(Agent):
+            channel = "my_agent"
+
+            def handle_request(self, msg):
+                goal = msg["payload"]["goal"]
+                # ... process ...
+                return {"summary": "done"}
+
+        MyAgent().run()
+    """
+
+    channel = None  # override in subclass — e.g. "researcher", "reviewer"
+
+    def __init__(self, agent_id=None):
+        self.agent_id = agent_id or self.__class__.__name__.lower()
+        self.bus = AgentBus(agent_id=self.agent_id)
+        self.store = TaskStore()
+
+    def handle_request(self, msg):
+        """Override this. Return dict with at least 'summary' key."""
+        raise NotImplementedError
+
+    def _process(self, msg):
+        goal = msg["payload"].get("goal", "")
+        conversation_id = msg["conversation_id"]
+        task_id = msg.get("task_id", "")
+        log_finding(self.agent_id, f"Processing: {goal[:60]}", f"task={task_id[:8]}")
+
+        if task_id:
+            self.store.update_status(task_id, "in_progress")
+
+        try:
+            result = self.handle_request(msg)
+            if task_id:
+                self.store.update_status(task_id, "done")
+        except Exception as e:
+            log_finding(self.agent_id, f"Error: {e}")
+            result = {"summary": f"Error: {e}"}
+            if task_id:
+                self.store.update_status(task_id, "blocked")
+
+        self.bus.publish("planner", {
+            "from": self.agent_id, "to": "planner", "intent": "RESPONSE",
+            "conversation_id": conversation_id, "task_id": task_id,
+            "payload": result,
+        })
+
+    def run(self):
+        if not self.channel:
+            raise ValueError("Agent.channel must be set")
+        print(f"[{self.agent_id}] Starting. Subscribing to bus:{self.channel}...", flush=True)
+        for msg in self.bus.subscribe(self.channel):
+            if msg is None:
+                continue
+            if msg.get("intent") == "REQUEST":
+                self._process(msg)

axeon_atrest-0.1.0/atrest/bus.py

@@ -0,0 +1,120 @@
+"""AT Rest — Redis Streams AgentBus wrapper."""
+import json, uuid
+from datetime import datetime, timezone
+
+import redis
+
+from atrest.config import REDIS_HOST, REDIS_PORT, REDIS_PASSWORD, REDIS_DB
+
+STREAMS = {
+    "planner": "bus:planner",
+    "researcher": "bus:researcher",
+    "reviewer": "bus:reviewer",
+    "mentor": "bus:mentor",
+    "broadcast": "bus:broadcast",
+    "conflict": "bus:conflict",
+    "dead_letter": "bus:dead_letter",
+}
+
+class AgentBus:
+    def __init__(self, agent_id="unknown"):
+        self.agent_id = agent_id
+        self.redis = redis.Redis(
+            host=REDIS_HOST, port=REDIS_PORT,
+            password=REDIS_PASSWORD, db=REDIS_DB,
+            decode_responses=True,
+        )
+        self.redis.ping()
+
+    # ── Stream helpers ────────────────────────────────────────────
+
+    def _stream(self, channel):
+        if channel in STREAMS:
+            return STREAMS[channel]
+        if isinstance(channel, str) and channel.startswith("bus:"):
+            return channel
+        return f"bus:{channel}"
+
+    # ── Envelope ──────────────────────────────────────────────────
+
+    def _envelope(self, msg):
+        return {
+            "msg_id": str(uuid.uuid4()),
+            "from": msg.get("from", self.agent_id),
+            "to": msg.get("to", ""),
+            "intent": msg.get("intent", "REQUEST"),
+            "task_id": msg.get("task_id") or "",
+            "payload": json.dumps(msg.get("payload", {}), ensure_ascii=False),
+            "conversation_id": msg.get("conversation_id") or str(uuid.uuid4()),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "ttl": str(msg.get("ttl", 30)),
+        }
+
+    def _decode(self, raw):
+        env = dict(raw)
+        if "payload" in env:
+            try:
+                env["payload"] = json.loads(env["payload"])
+            except (json.JSONDecodeError, TypeError):
+                env["payload"] = {}
+        return env
+
+    # ── Publish ───────────────────────────────────────────────────
+
+    def publish(self, channel, message):
+        stream = self._stream(channel)
+        env = self._envelope(message)
+        return self.redis.xadd(stream, env, maxlen=10000)
+
+    # ── Subscribe (consumer group) ───────────────────────────────
+
+    def subscribe(self, channel, group=None, consumer=None):
+        stream = self._stream(channel)
+        group_name = group or f"atrest-{stream}"
+        consumer_id = consumer or f"{self.agent_id}-{uuid.uuid4().hex[:8]}"
+
+        try:
+            self.redis.xgroup_create(stream, group_name, id="0", mkstream=True)
+        except redis.exceptions.ResponseError as e:
+            if "BUSYGROUP" not in str(e):
+                raise
+
+        while True:
+            try:
+                results = self.redis.xreadgroup(
+                    group_name, consumer_id, {stream: ">"},
+                    block=5000, count=1,
+                )
+            except redis.exceptions.ConnectionError:
+                yield None
+                continue
+            except redis.exceptions.TimeoutError:
+                continue
+            except redis.exceptions.ResponseError as e:
+                # NOGROUP — stream or consumer group was deleted, recreate
+                if "NOGROUP" in str(e):
+                    try:
+                        self.redis.xgroup_create(stream, group_name, id="0", mkstream=True)
+                    except redis.exceptions.ResponseError:
+                        pass
+                    continue
+                raise
+
+            if results:
+                for stream_name, messages in results:
+                    for msg_id, msg_data in messages:
+                        yield self._decode(msg_data)
+                        self.redis.xack(stream, group_name, msg_id)
+            else:
+                yield None  # tick — allows caller to process timeouts
+
+    # ── Dead letter ──────────────────────────────────────────────
+
+    def dead_letter(self, original_msg, reason):
+        self.publish("dead_letter", {
+            "intent": "DEAD_LETTER",
+            "payload": {
+                "original_msg_id": original_msg.get("msg_id", ""),
+                "reason": str(reason),
+            },
+        })

axeon_atrest-0.1.0/atrest/client.py

@@ -0,0 +1,53 @@
+"""AT Rest — API Client. Wraps REST calls to AT Rest API server."""
+import httpx
+
+class ATRestClient:
+    """Minimal client for AT Rest API.
+
+    Usage:
+        client = ATRestClient("http://localhost:8080")
+        resp = client.research("Redis configuration")
+        print(resp["summary"])
+    """
+
+    def __init__(self, base_url="http://localhost:8080", timeout=30):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    def _post(self, path, data):
+        r = httpx.post(f"{self.base_url}{path}", json=data, timeout=self.timeout)
+        r.raise_for_status()
+        return r.json()
+
+    def _get(self, path, params=None):
+        r = httpx.get(f"{self.base_url}{path}", params=params, timeout=self.timeout)
+        r.raise_for_status()
+        return r.json()
+
+    def health(self):
+        return self._get("/v1/health")
+
+    def create_task(self, goal, hint="researcher"):
+        return self._post("/v1/tasks", {"goal": goal, "hint": hint})
+
+    def get_task(self, task_id):
+        return self._get(f"/v1/tasks/{task_id}")
+
+    def list_tasks(self, status=None):
+        params = {"status": status} if status else {}
+        return self._get("/v1/tasks", params=params)
+
+    def task_lineage(self, task_id):
+        return self._get(f"/v1/tasks/{task_id}/lineage")
+
+    def research(self, query, limit=3):
+        return self._post("/v1/research", {"query": query, "limit": limit})
+
+    def graph_explore(self, query, limit=5):
+        return self._get("/v1/graph/explore", params={"query": query, "limit": limit})
+
+    def infra_dependencies(self):
+        return self._get("/v1/graph/dependencies")
+
+    def review(self, path):
+        return self._post("/v1/review", {"path": path})

axeon_atrest-0.1.0/atrest/config.py

@@ -0,0 +1,33 @@
+"""AT Rest — centralized configuration from environment."""
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Redis
+REDIS_HOST = os.getenv("REDIS_HOST", "localhost")
+REDIS_PORT = int(os.getenv("REDIS_PORT", "6379"))
+REDIS_PASSWORD = os.getenv("REDIS_PASSWORD") or None
+REDIS_DB = int(os.getenv("REDIS_DB", "0"))
+
+# Neo4j
+NEO4J_URI = os.getenv("NEO4J_URI", "bolt://localhost:7687")
+NEO4J_USER = os.getenv("NEO4J_USER", "neo4j")
+NEO4J_PASSWORD = os.getenv("NEO4J_PASSWORD", "")
+
+# Qdrant
+QDRANT_HOST = os.getenv("QDRANT_HOST", "localhost")
+QDRANT_PORT = int(os.getenv("QDRANT_PORT", "6333"))
+QDRANT_URL = f"http://{QDRANT_HOST}:{QDRANT_PORT}"
+QDRANT_COLLECTION = os.getenv("QDRANT_COLLECTION", "knowledge")
+
+# Ollama
+OLLAMA_BASE_URL = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
+OLLAMA_MODEL = os.getenv("OLLAMA_MODEL", "qwen2.5:1.5b")
+EMBED_MODEL = os.getenv("EMBED_MODEL", "nomic-embed-text")
+
+# AT Rest
+ATREST_LOG_DIR = Path(os.getenv("ATREST_LOG_DIR", "./logs"))
+ATREST_ENV = os.getenv("ATREST_ENV", "development")
+PROJECT_ROOT = Path(__file__).resolve().parent.parent

axeon_atrest-0.1.0/atrest/context.py

@@ -0,0 +1,28 @@
+"""AT Rest — thin cached wrapper for context-builder.py from memory/."""
+import os, sys, importlib.util
+from pathlib import Path
+
+_MEMORY_ROOT = Path(os.getenv("ATREST_MEMORY_PATH", os.path.expanduser("~/memory")))
+_CACHE = {}
+
+def _load_cb():
+    if "cb" in _CACHE:
+        return _CACHE["cb"]
+    path = _MEMORY_ROOT / "context-builder.py"
+    if not path.exists():
+        return None
+    spec = importlib.util.spec_from_file_location("context_builder", str(path))
+    mod = importlib.util.module_from_spec(spec)
+    sys.path.insert(0, str(_MEMORY_ROOT))
+    try:
+        spec.loader.exec_module(mod)
+    except Exception:
+        return None
+    _CACHE["cb"] = mod
+    return mod
+
+def infra_traverse(query):
+    mod = _load_cb()
+    if mod is None:
+        return {}
+    return mod.infra_traverse(query)

axeon_atrest-0.1.0/atrest/llm.py

@@ -0,0 +1,16 @@
+"""AT Rest — shared Ollama helpers (generate + embed)."""
+import httpx
+from atrest.config import OLLAMA_BASE_URL, OLLAMA_MODEL, EMBED_MODEL
+
+def generate(prompt, max_tokens=400, temperature=0.1, timeout=60):
+    r = httpx.post(f"{OLLAMA_BASE_URL}/api/generate", json={
+        "model": OLLAMA_MODEL, "prompt": prompt,
+        "stream": False, "options": {"temperature": temperature, "num_predict": max_tokens},
+    }, timeout=timeout)
+    r.raise_for_status()
+    return r.json()["response"].strip()
+
+def embed(text, timeout=30):
+    r = httpx.post(f"{OLLAMA_BASE_URL}/api/embeddings",
+        json={"model": EMBED_MODEL, "prompt": text}, timeout=timeout)
+    return r.json()["embedding"]

axeon_atrest-0.1.0/atrest/qdrant.py

@@ -0,0 +1,11 @@
+"""AT Rest — shared Qdrant search."""
+import httpx
+from atrest.config import QDRANT_URL, QDRANT_COLLECTION
+from atrest.llm import embed
+
+def search(query, limit=3):
+    vec = embed(query)
+    r = httpx.post(f"{QDRANT_URL}/collections/{QDRANT_COLLECTION}/points/search", json={
+        "vector": vec, "limit": limit, "with_payload": True,
+    }, timeout=10)
+    return r.json().get("result", [])

axeon_atrest-0.1.0/atrest/task_store.py

@@ -0,0 +1,100 @@
+"""AT Rest — Neo4j AgentTask persistence."""
+import time, uuid
+from datetime import datetime, timezone
+
+from neo4j import GraphDatabase
+from neo4j.exceptions import TransientError
+
+from atrest.config import NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD
+
+class TaskStore:
+    def __init__(self):
+        self.driver = GraphDatabase.driver(NEO4J_URI, auth=(NEO4J_USER, NEO4J_PASSWORD))
+        self._ensure_constraint()
+
+    def _ensure_constraint(self):
+        for attempt in range(3):
+            try:
+                with self.driver.session() as s:
+                    s.run(
+                        "CREATE CONSTRAINT IF NOT EXISTS FOR (t:AgentTask) REQUIRE t.id IS UNIQUE"
+                    )
+                return
+            except TransientError:
+                if attempt < 2:
+                    time.sleep(0.5 * (attempt + 1))
+                    continue
+                raise
+
+    def create_task(self, goal, assigned_to, created_by, parent_id=None, parent_goal=None):
+        task_id = str(uuid.uuid4())
+        now = datetime.now(timezone.utc).isoformat()
+        with self.driver.session() as s:
+            s.run(
+                """CREATE (t:AgentTask {id: $id, goal: $goal, parent_goal: $parent_goal, status: 'pending',
+                   assigned_to: $assigned_to, created_by: $created_by,
+                   parent_task_id: $parent_id,
+                   created_at: $now, updated_at: $now})""",
+                id=task_id, goal=goal, parent_goal=parent_goal, assigned_to=assigned_to,
+                created_by=created_by, parent_id=parent_id, now=now,
+            )
+        return task_id
+
+    def update_status(self, task_id, status):
+        now = datetime.now(timezone.utc).isoformat()
+        with self.driver.session() as s:
+            s.run(
+                "MATCH (t:AgentTask {id: $id}) SET t.status = $status, t.updated_at = $now",
+                id=task_id, status=status, now=now,
+            )
+
+    def get_task(self, task_id):
+        with self.driver.session() as s:
+            row = s.run(
+                "MATCH (t:AgentTask {id: $id}) RETURN t.id AS id, t.goal AS goal, "
+                "t.status AS status, t.assigned_to AS assigned_to, "
+                "t.created_by AS created_by, t.parent_task_id AS parent_task_id, "
+                "t.created_at AS created_at, t.updated_at AS updated_at",
+                id=task_id,
+            ).single()
+            return dict(row) if row else None
+
+    def find_duplicate(self, goal):
+        with self.driver.session() as s:
+            row = s.run(
+                "MATCH (t:AgentTask {goal: $goal, status: 'done'}) "
+                "RETURN t.id AS id LIMIT 1",
+                goal=goal,
+            ).single()
+            return row["id"] if row else None
+
+    def find_duplicate_by_parent_goal(self, parent_goal):
+        with self.driver.session() as s:
+            row = s.run(
+                "MATCH (t:AgentTask {parent_goal: $pg, status: 'done'}) "
+                "RETURN t.id AS id LIMIT 1",
+                pg=parent_goal,
+            ).single()
+            return row["id"] if row else None
+
+    def link_reference(self, task_id, node_id, node_label):
+        with self.driver.session() as s:
+            s.run(
+                f"MATCH (t:AgentTask {{id: $task_id}}) "
+                f"MATCH (n:{node_label} {{id: $node_id}}) "
+                f"MERGE (t)-[:REFERENCES]->(n)",
+                task_id=task_id, node_id=node_id,
+            )
+
+    def get_task_by_goal(self, goal):
+        with self.driver.session() as s:
+            rows = list(s.run(
+                "MATCH (t:AgentTask) WHERE t.goal = $goal OR t.parent_goal = $goal "
+                "RETURN t.id AS id, t.status AS status "
+                "ORDER BY t.created_at ASC",
+                goal=goal,
+            ))
+            return [dict(r) for r in rows]
+
+    def close(self):
+        self.driver.close()

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

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: axeon-atrest
+Version: 0.1.0
+Summary: Agent Task Runtime & State Transport — middleware for AI agent communication, memory, and task lifecycle
+License-Expression: MIT
+Keywords: ai,agents,multi-agent,orchestration,middleware,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: redis>=5.0
+Requires-Dist: neo4j>=5.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: pydantic>=2.0
+Provides-Extra: api
+Requires-Dist: fastapi>=0.100; extra == "api"
+Requires-Dist: uvicorn>=0.22; extra == "api"
+Provides-Extra: all
+Requires-Dist: fastapi>=0.100; extra == "all"
+Requires-Dist: uvicorn>=0.22; extra == "all"
+
+# AT Rest — Agent Task Runtime & State Transport
+
+Middleware untuk agent communication, memory, dan task lifecycle.
+
+4 agent built-in (planner, researcher, reviewer, mentor) via Redis Streams bus.
+Neo4j task persistence. FastAPI REST API server. Qdrant + Neo4j knowledge retrieval.
+
+## Quick Start
+
+```bash
+pip install atrest
+```
+
+```python
+from atrest import Agent, generate, search
+
+class MyAgent(Agent):
+    channel = "researcher"
+
+    def handle_request(self, msg):
+        goal = msg["payload"]["goal"]
+        results = search(goal, limit=3)
+        summary = generate(f"Summarize: {goal}\n\nContext: {results}")
+        return {"summary": summary, "sources": []}
+
+MyAgent().run()
+```
+
+## Available Imports
+
+```python
+from atrest import Agent, ATRestClient, AgentBus, TaskStore, generate, embed, search
+```
+
+- `Agent` — base class for custom agents
+- `ATRestClient` — HTTP client for AT Rest API
+- `AgentBus` — Redis Streams pub/sub
+- `TaskStore` — Neo4j AgentTask persistence
+- `generate()` — Ollama LLM call
+- `embed()` — Ollama embedding
+- `search()` — Qdrant vector search
+
+## Optional: API Server
+
+```bash
+pip install atrest[api]
+python -m api.server
+```
+
+## Architecture
+
+```
+User → REST API / Agent SDK → Agent Bus (Redis Streams)
+  → Planner → Researcher / Reviewer / Mentor
+  → Task Store (Neo4j) → Broadcast
+  → Knowledge (Qdrant + Neo4j)
+```
+
+## License
+
+MIT