querymemory 0.1.0__py3-none-any.whl

querymemory-0.1.0.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: querymemory
+Version: 0.1.0
+Summary: Official Query Memory SDK for Knowledge, Agent, and Web Parsing APIs
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+
+# Query Memory Python SDK
+
+Official SDK for Query Memory Knowledge, Agent, and Web Parsing APIs.
+
+## Install
+
+```bash
+pip install querymemory-sdk
+```
+
+## Quick Start
+
+```python
+from querymemory_sdk import QueryMemoryClient
+
+client = QueryMemoryClient(
+    base_url="https://api.querymemory.com",
+    api_key="<USER_API_KEY>",
+)
+
+result = client.knowledge.query(
+    knowledge_id="<KNOWLEDGE_ID>",
+    query="Summarize key points",
+    top_k=5,
+)
+
+print(result)
+```
+
+Use root domain for `base_url` (no `/api/v1`):
+
+- Correct: `https://api.querymemory.com`
+- Incorrect: `https://api.querymemory.com/api/v1`
+
+## Auth
+
+- Public query APIs use `api_key`.
+- Management APIs can use `api_key` (user API key) or `auth_token` depending on deployment policy.
+
+You can pass one or both to one client.
+
+## Modules
+
+- `client.knowledge`
+- `client.agents`
+- `client.web`
+
+Each module includes both management and public query helpers.

querymemory-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+querymemory_sdk/__init__.py,sha256=-Rg--eN4tCkd3W2PTtzvmjWbIEqQO5FN9gV5vhJdj4M,109
+querymemory_sdk/client.py,sha256=nj4KIt-9fTHZ1yZvD60t9P4dq6GqHXYfB4Kvq4RJfnM,11386
+querymemory-0.1.0.dist-info/METADATA,sha256=iCElgL1mYt6lVjFSp9G2OwMI9LvS8xWTHHemyiKM00w,1150
+querymemory-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+querymemory-0.1.0.dist-info/top_level.txt,sha256=ffEr1Qj_8eoIGmcNisIAqWoMdGwlA6Vek1yTyu9mNWg,16
+querymemory-0.1.0.dist-info/RECORD,,

querymemory-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

querymemory-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+querymemory_sdk

querymemory_sdk/__init__.py

@@ -0,0 +1,3 @@
+from .client import QueryMemoryClient, QueryMemoryError
+
+__all__ = ["QueryMemoryClient", "QueryMemoryError"]

querymemory_sdk/client.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+import requests
+
+
+class QueryMemoryError(Exception):
+    def __init__(self, message: str, status: int = 0, details: Any = None):
+        super().__init__(message)
+        self.status = status
+        self.details = details
+
+
+@dataclass
+class QueryMemoryClientOptions:
+    base_url: str = "http://localhost:8000"
+    api_key: Optional[str] = None
+    auth_token: Optional[str] = None
+    timeout: int = 60
+    default_headers: Optional[Dict[str, str]] = None
+
+
+class _HttpClient:
+    def __init__(self, options: QueryMemoryClientOptions):
+        self.base_url = options.base_url.rstrip("/")
+        self.api_key = options.api_key
+        self.auth_token = options.auth_token
+        self.timeout = options.timeout
+        self.default_headers = options.default_headers or {}
+        self.session = requests.Session()
+
+    def _headers(self, auth_mode: str = "auto") -> Dict[str, str]:
+        headers = dict(self.default_headers)
+        if auth_mode in ("api_key", "auto") and self.api_key:
+            headers["X-API-Key"] = self.api_key
+        elif auth_mode in ("auth_token", "auto") and self.auth_token:
+            headers["Authorization"] = f"Bearer {self.auth_token}"
+        return headers
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        json_body: Optional[Dict[str, Any]] = None,
+        auth_mode: str = "auto",
+    ) -> Dict[str, Any]:
+        url = f"{self.base_url}{path}"
+        try:
+            response = self.session.request(
+                method=method,
+                url=url,
+                params={k: v for k, v in (params or {}).items() if v is not None},
+                json=json_body,
+                headers=self._headers(auth_mode),
+                timeout=self.timeout,
+            )
+        except requests.RequestException as exc:
+            raise QueryMemoryError(str(exc), 0) from exc
+
+        payload: Any
+        try:
+            payload = response.json()
+        except Exception:
+            payload = {"detail": response.text}
+
+        if not response.ok:
+            detail = payload.get("detail") if isinstance(payload, dict) else str(payload)
+            raise QueryMemoryError(detail or response.reason, response.status_code, payload)
+
+        if isinstance(payload, dict):
+            return payload
+        return {"data": payload}
+
+    def wait_for_task(
+        self,
+        path: str,
+        *,
+        timeout_sec: int = 120,
+        interval_sec: float = 1.0,
+        auth_mode: str = "auto",
+    ) -> Dict[str, Any]:
+        started = time.time()
+        while time.time() - started < timeout_sec:
+            status = self.request("GET", path, auth_mode=auth_mode)
+            state = str(status.get("status", "")).lower()
+            if state in ("completed", "success"):
+                result = status.get("result")
+                if isinstance(result, dict):
+                    return result
+                return status
+            if state == "failed":
+                raise QueryMemoryError(status.get("error", "Task failed"), 500, status)
+            time.sleep(interval_sec)
+        raise QueryMemoryError(f"Task polling timed out after {timeout_sec}s", 408)
+
+
+class KnowledgeApi:
+    def __init__(self, http: _HttpClient):
+        self._http = http
+
+    def list(self) -> Dict[str, Any]:
+        return self._http.request("GET", "/api/v1/knowledges", auth_mode="auto")
+
+    def get(self, knowledge_id: str) -> Dict[str, Any]:
+        return self._http.request("GET", f"/api/v1/knowledges/{knowledge_id}", auth_mode="auto")
+
+    def create(self, *, name: str, description: Optional[str] = None, connected_documents: Optional[list[str]] = None) -> Dict[str, Any]:
+        return self._http.request(
+            "POST",
+            "/api/v1/knowledges",
+            auth_mode="auto",
+            json_body={
+                "name": name,
+                "description": description,
+                "connected_documents": connected_documents or [],
+            },
+        )
+
+    def update(self, knowledge_id: str, **payload: Any) -> Dict[str, Any]:
+        return self._http.request("PUT", f"/api/v1/knowledges/{knowledge_id}", auth_mode="auto", json_body=payload)
+
+    def delete(self, knowledge_id: str) -> Dict[str, Any]:
+        return self._http.request("DELETE", f"/api/v1/knowledges/{knowledge_id}", auth_mode="auto")
+
+    def query(
+        self,
+        *,
+        knowledge_id: str,
+        query: str,
+        top_k: int = 5,
+        retrieve_k: Optional[int] = None,
+        include_context: bool = True,
+        wait_for_result: bool = True,
+        wait_timeout_sec: int = 45,
+    ) -> Dict[str, Any]:
+        return self._http.request(
+            "POST",
+            f"/api/v1/knowledge/{knowledge_id}/query",
+            auth_mode="api_key",
+            params={
+                "top_k": top_k,
+                "retrieve_k": retrieve_k,
+                "wait_for_result": wait_for_result,
+                "wait_timeout_sec": wait_timeout_sec,
+            },
+            json_body={
+                "query": query,
+                "top_k": top_k,
+                "retrieve_k": retrieve_k,
+                "include_context": include_context,
+            },
+        )
+
+    def get_query_job(self, task_id: str) -> Dict[str, Any]:
+        return self._http.request("GET", f"/api/v1/knowledge/query-jobs/{task_id}", auth_mode="api_key")
+
+    def wait_for_query_job(self, task_id: str, *, timeout_sec: int = 120, interval_sec: float = 1.0) -> Dict[str, Any]:
+        return self._http.wait_for_task(
+            f"/api/v1/knowledge/query-jobs/{task_id}",
+            timeout_sec=timeout_sec,
+            interval_sec=interval_sec,
+            auth_mode="api_key",
+        )
+
+
+class AgentsApi:
+    def __init__(self, http: _HttpClient):
+        self._http = http
+
+    def list(self) -> Dict[str, Any]:
+        return self._http.request("GET", "/api/v1/agents", auth_mode="auto")
+
+    def get(self, agent_id: str) -> Dict[str, Any]:
+        return self._http.request("GET", f"/api/v1/agents/{agent_id}", auth_mode="auto")
+
+    def create(self, **payload: Any) -> Dict[str, Any]:
+        return self._http.request("POST", "/api/v1/agents", auth_mode="auto", json_body=payload)
+
+    def update(self, agent_id: str, **payload: Any) -> Dict[str, Any]:
+        return self._http.request("PUT", f"/api/v1/agents/{agent_id}", auth_mode="auto", json_body=payload)
+
+    def create_session(self, agent_id: str, title: Optional[str] = None) -> Dict[str, Any]:
+        return self._http.request("POST", f"/api/v1/agents/{agent_id}/sessions", auth_mode="auto", json_body={"title": title})
+
+    def list_sessions(self, agent_id: str) -> Dict[str, Any]:
+        return self._http.request("GET", f"/api/v1/agents/{agent_id}/sessions", auth_mode="auto")
+
+    def get_session(self, agent_id: str, session_id: str) -> Dict[str, Any]:
+        return self._http.request("GET", f"/api/v1/agents/{agent_id}/sessions/{session_id}", auth_mode="auto")
+
+    def send_session_message(
+        self,
+        *,
+        agent_id: str,
+        session_id: str,
+        message: str,
+        wait_for_result: bool = True,
+        wait_timeout_sec: int = 90,
+    ) -> Dict[str, Any]:
+        return self._http.request(
+            "POST",
+            f"/api/v1/agents/{agent_id}/sessions/{session_id}/messages",
+            auth_mode="auto",
+            json_body={
+                "message": message,
+                "wait_for_result": wait_for_result,
+                "wait_timeout_sec": wait_timeout_sec,
+            },
+        )
+
+    def query(
+        self,
+        *,
+        agent_id: str,
+        query: str,
+        wait_for_result: bool = True,
+        wait_timeout_sec: int = 90,
+        external_user_id: Optional[str] = None,
+        external_session_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        return self._http.request(
+            "POST",
+            f"/api/v1/agents/{agent_id}/query",
+            auth_mode="api_key",
+            json_body={
+                "query": query,
+                "wait_for_result": wait_for_result,
+                "wait_timeout_sec": wait_timeout_sec,
+                "external_user_id": external_user_id,
+                "external_session_id": external_session_id,
+            },
+        )
+
+    def get_users(self, agent_id: str) -> Dict[str, Any]:
+        return self._http.request("GET", f"/api/v1/agents/{agent_id}/users", auth_mode="api_key")
+
+    def get_job(self, task_id: str) -> Dict[str, Any]:
+        return self._http.request("GET", f"/api/v1/agents/jobs/{task_id}", auth_mode="api_key")
+
+    def wait_for_job(self, task_id: str, *, timeout_sec: int = 120, interval_sec: float = 1.0) -> Dict[str, Any]:
+        return self._http.wait_for_task(
+            f"/api/v1/agents/jobs/{task_id}",
+            timeout_sec=timeout_sec,
+            interval_sec=interval_sec,
+            auth_mode="api_key",
+        )
+
+
+class WebApi:
+    def __init__(self, http: _HttpClient):
+        self._http = http
+
+    def list_endpoints(self) -> Dict[str, Any]:
+        return self._http.request("GET", "/api/v1/web-parsing-endpoints", auth_mode="auto")
+
+    def get_endpoint(self, endpoint_id: str) -> Dict[str, Any]:
+        return self._http.request("GET", f"/api/v1/web-parsing-endpoints/{endpoint_id}", auth_mode="auto")
+
+    def create_endpoint(self, **payload: Any) -> Dict[str, Any]:
+        return self._http.request("POST", "/api/v1/web-parsing-endpoints", auth_mode="auto", json_body=payload)
+
+    def update_endpoint(self, endpoint_id: str, **payload: Any) -> Dict[str, Any]:
+        return self._http.request("PUT", f"/api/v1/web-parsing-endpoints/{endpoint_id}", auth_mode="auto", json_body=payload)
+
+    def delete_endpoint(self, endpoint_id: str) -> Dict[str, Any]:
+        return self._http.request("DELETE", f"/api/v1/web-parsing-endpoints/{endpoint_id}", auth_mode="auto")
+
+    def query(
+        self,
+        *,
+        endpoint_id: str,
+        query: str,
+        max_pages: Optional[int] = None,
+        domains: Optional[list[str]] = None,
+        output_format: Optional[str] = None,
+        options: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        return self._http.request(
+            "POST",
+            f"/api/v1/web-parsing-endpoints/{endpoint_id}/query",
+            auth_mode="api_key",
+            json_body={
+                "query": query,
+                "max_pages": max_pages,
+                "domains": domains,
+                "output_format": output_format,
+                "options": options or {},
+            },
+        )
+
+
+class QueryMemoryClient:
+    def __init__(
+        self,
+        *,
+        base_url: str = "http://localhost:8000",
+        api_key: Optional[str] = None,
+        auth_token: Optional[str] = None,
+        timeout: int = 60,
+        default_headers: Optional[Dict[str, str]] = None,
+    ):
+        http = _HttpClient(
+            QueryMemoryClientOptions(
+                base_url=base_url,
+                api_key=api_key,
+                auth_token=auth_token,
+                timeout=timeout,
+                default_headers=default_headers,
+            )
+        )
+        self.knowledge = KnowledgeApi(http)
+        self.agents = AgentsApi(http)
+        self.web = WebApi(http)