locaith 1.0.0__py3-none-any.whl

locaith/__init__.py

@@ -0,0 +1,33 @@
+from ._client import AsyncLocaith, Locaith
+from ._errors import (
+    APIConnectionError,
+    APIStatusError,
+    APITimeoutError,
+    AuthenticationError,
+    BadRequestError,
+    InternalServerError,
+    LocaithError,
+    NotFoundError,
+    RateLimitError,
+)
+from ._types import AsyncStream, ChatCompletion, ChatCompletionChunk, Stream
+from ._version import __version__
+
+__all__ = [
+    "Locaith",
+    "AsyncLocaith",
+    "ChatCompletion",
+    "ChatCompletionChunk",
+    "Stream",
+    "AsyncStream",
+    "LocaithError",
+    "APIConnectionError",
+    "APITimeoutError",
+    "APIStatusError",
+    "BadRequestError",
+    "AuthenticationError",
+    "NotFoundError",
+    "RateLimitError",
+    "InternalServerError",
+    "__version__",
+]

locaith/_client.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import time
+from typing import Any, Dict, Mapping, Optional, Union
+
+import httpx
+
+from ._errors import APIConnectionError, APITimeoutError, LocaithError, make_status_error
+from ._resources import AsyncChat, AsyncMemory, AsyncModels, Chat, Memory, Models
+from ._version import __version__
+
+DEFAULT_BASE_URL = "https://memory-api.locaith.com/v1"
+DEFAULT_TIMEOUT = 900.0
+DEFAULT_MAX_RETRIES = 2
+_RETRY_STATUS = {502, 503, 504}
+
+
+class _BaseClient:
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str],
+        base_url: Optional[str],
+        timeout: Union[float, httpx.Timeout],
+        max_retries: int,
+        user: Optional[str],
+        default_headers: Optional[Mapping[str, str]],
+    ) -> None:
+        api_key = api_key or os.environ.get("LOCAITH_API_KEY")
+        if not api_key:
+            raise LocaithError(
+                "Thiếu API key. Truyền Locaith(api_key=...) hoặc đặt biến môi trường LOCAITH_API_KEY."
+            )
+        self.api_key = api_key
+        self.base_url = (base_url or os.environ.get("LOCAITH_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout if isinstance(timeout, httpx.Timeout) else httpx.Timeout(timeout, connect=10.0)
+        self.max_retries = max_retries
+        self.user = user
+        self._headers: Dict[str, str] = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": f"locaith-python/{__version__}",
+            **(default_headers or {}),
+        }
+
+    def _url(self, path: str) -> str:
+        return self.base_url + path
+
+    @staticmethod
+    def _delay(attempt: int) -> float:
+        return min(0.5 * (2**attempt), 8.0)
+
+    @staticmethod
+    def _body(response: httpx.Response) -> Any:
+        try:
+            return response.json()
+        except ValueError:
+            return {"detail": response.text[:500]}
+
+
+class Locaith(_BaseClient):
+    """Client đồng bộ.
+
+        from locaith import Locaith
+        client = Locaith()          # đọc LOCAITH_API_KEY
+        r = client.chat.completions.create(messages=[{"role": "user", "content": "Xin chào"}])
+        print(r.choices[0].message.content)
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        base_url: Optional[str] = None,
+        timeout: Union[float, httpx.Timeout] = DEFAULT_TIMEOUT,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        user: Optional[str] = None,
+        default_headers: Optional[Mapping[str, str]] = None,
+        http_client: Optional[httpx.Client] = None,
+    ) -> None:
+        super().__init__(api_key=api_key, base_url=base_url, timeout=timeout, max_retries=max_retries, user=user,
+                         default_headers=default_headers)
+        self._http = http_client or httpx.Client(timeout=self.timeout)
+        self.chat = Chat(self)
+        self.models = Models(self)
+        self.memory = Memory(self)
+
+    def _send(self, method: str, path: str, *, json: Any = None, params: Optional[dict] = None,
+              stream: bool = False) -> httpx.Response:
+        req = self._http.build_request(method, self._url(path), json=json, params=params,
+                                       headers=self._headers, timeout=self.timeout)
+        attempt = 0
+        while True:
+            try:
+                resp = self._http.send(req, stream=stream)
+            except httpx.TimeoutException as e:
+                if attempt >= self.max_retries:
+                    raise APITimeoutError("Quá thời gian chờ phản hồi.") from e
+            except httpx.TransportError as e:
+                if attempt >= self.max_retries:
+                    raise APIConnectionError(f"Không kết nối được: {type(e).__name__}") from e
+            else:
+                if resp.status_code in _RETRY_STATUS and attempt < self.max_retries:
+                    resp.close()
+                elif resp.status_code >= 400:
+                    if stream:
+                        resp.read()
+                    err = make_status_error(resp.status_code, self._body(resp))
+                    resp.close()
+                    raise err
+                else:
+                    return resp
+            time.sleep(self._delay(attempt))
+            attempt += 1
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "Locaith":
+        return self
+
+    def __exit__(self, *a: Any) -> None:
+        self.close()
+
+
+class AsyncLocaith(_BaseClient):
+    """Client bất đồng bộ (asyncio), cùng giao diện với Locaith."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        base_url: Optional[str] = None,
+        timeout: Union[float, httpx.Timeout] = DEFAULT_TIMEOUT,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        user: Optional[str] = None,
+        default_headers: Optional[Mapping[str, str]] = None,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> None:
+        super().__init__(api_key=api_key, base_url=base_url, timeout=timeout, max_retries=max_retries, user=user,
+                         default_headers=default_headers)
+        self._http = http_client or httpx.AsyncClient(timeout=self.timeout)
+        self.chat = AsyncChat(self)
+        self.models = AsyncModels(self)
+        self.memory = AsyncMemory(self)
+
+    async def _send(self, method: str, path: str, *, json: Any = None, params: Optional[dict] = None,
+                    stream: bool = False) -> httpx.Response:
+        req = self._http.build_request(method, self._url(path), json=json, params=params,
+                                       headers=self._headers, timeout=self.timeout)
+        attempt = 0
+        while True:
+            try:
+                resp = await self._http.send(req, stream=stream)
+            except httpx.TimeoutException as e:
+                if attempt >= self.max_retries:
+                    raise APITimeoutError("Quá thời gian chờ phản hồi.") from e
+            except httpx.TransportError as e:
+                if attempt >= self.max_retries:
+                    raise APIConnectionError(f"Không kết nối được: {type(e).__name__}") from e
+            else:
+                if resp.status_code in _RETRY_STATUS and attempt < self.max_retries:
+                    await resp.aclose()
+                elif resp.status_code >= 400:
+                    if stream:
+                        await resp.aread()
+                    err = make_status_error(resp.status_code, self._body(resp))
+                    await resp.aclose()
+                    raise err
+                else:
+                    return resp
+            await asyncio.sleep(self._delay(attempt))
+            attempt += 1
+
+    async def close(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self) -> "AsyncLocaith":
+        return self
+
+    async def __aexit__(self, *a: Any) -> None:
+        await self.close()

locaith/_errors.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class LocaithError(Exception):
+    """Lỗi gốc của SDK."""
+
+
+class APIConnectionError(LocaithError):
+    """Không kết nối được tới máy chủ."""
+
+
+class APITimeoutError(APIConnectionError):
+    """Quá thời gian chờ."""
+
+
+class APIStatusError(LocaithError):
+    """Máy chủ trả mã lỗi HTTP."""
+
+    def __init__(self, message: str, *, status_code: int, body: Any = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.body = body
+
+    def __str__(self) -> str:
+        return f"Error code: {self.status_code} - {self.message}"
+
+
+class BadRequestError(APIStatusError):
+    """400"""
+
+
+class AuthenticationError(APIStatusError):
+    """401: sai hoặc thiếu API key"""
+
+
+class NotFoundError(APIStatusError):
+    """404"""
+
+
+class RateLimitError(APIStatusError):
+    """429"""
+
+
+class InternalServerError(APIStatusError):
+    """5xx"""
+
+
+def make_status_error(status: int, body: Any) -> APIStatusError:
+    msg: Optional[str] = None
+    if isinstance(body, dict):
+        err = body.get("error")
+        if isinstance(err, dict):
+            msg = err.get("message")
+        elif isinstance(body.get("detail"), str):
+            msg = body["detail"]
+    msg = msg or f"HTTP {status}"
+    cls = {400: BadRequestError, 401: AuthenticationError, 404: NotFoundError, 429: RateLimitError}.get(status)
+    if cls is None:
+        cls = InternalServerError if status >= 500 else APIStatusError
+    return cls(msg, status_code=status, body=body)

locaith/_resources.py

@@ -0,0 +1,199 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Union
+
+from ._types import AsyncStream, AttrDict, ChatCompletion, Stream
+
+if TYPE_CHECKING:
+    from ._client import AsyncLocaith, Locaith
+
+DEFAULT_MODEL = "Locaith-4-flash"
+MEMORY_TYPES = ("user", "feedback", "project", "reference")
+
+
+def _chat_body(c: Any, *, messages: Union[str, Iterable[Dict[str, Any]]], model: str, stream: bool,
+               web_search: bool, memory: bool, user: Optional[str], extra_body: Optional[Dict[str, Any]],
+               params: Dict[str, Any]) -> Dict[str, Any]:
+    if isinstance(messages, str):
+        messages = [{"role": "user", "content": messages}]
+    body: Dict[str, Any] = {"model": model, "messages": list(messages), "web_search": web_search, "memory": memory}
+    u = user or c.user
+    if u:
+        body["user"] = u
+    body.update({k: v for k, v in params.items() if v is not None})
+    if stream:
+        body["stream"] = True
+    if extra_body:
+        body.update(extra_body)
+    return body
+
+
+def _qs(c: Any, user: Optional[str]) -> Dict[str, str]:
+    u = user or c.user
+    return {"user": u} if u else {}
+
+
+def _check_type(type: str) -> None:
+    if type not in MEMORY_TYPES:
+        raise ValueError(f"type phải là một trong {MEMORY_TYPES}")
+
+
+# ------------------------------------------------------------------ đồng bộ
+class Completions:
+    def __init__(self, client: "Locaith") -> None:
+        self._c = client
+
+    def create(
+        self,
+        *,
+        messages: Union[str, Iterable[Dict[str, Any]]],
+        model: str = DEFAULT_MODEL,
+        stream: bool = False,
+        web_search: bool = True,
+        memory: bool = False,
+        user: Optional[str] = None,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        stop: Union[str, List[str], None] = None,
+        seed: Optional[int] = None,
+        presence_penalty: Optional[float] = None,
+        frequency_penalty: Optional[float] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Union[str, Dict[str, Any], None] = None,
+        response_format: Optional[Dict[str, Any]] = None,
+        reasoning_effort: Optional[str] = None,
+        extra_body: Optional[Dict[str, Any]] = None,
+    ) -> Union[ChatCompletion, Stream]:
+        """Tạo câu trả lời. Luôn suy luận. web_search=True (mặc định) tự tìm web;
+        memory=True dùng Bio-Memory (ký ức dài hạn + điểm lưu khi hết ngữ cảnh).
+        stream=True trả về Stream."""
+        params = dict(temperature=temperature, top_p=top_p, max_tokens=max_tokens, stop=stop, seed=seed,
+                      presence_penalty=presence_penalty, frequency_penalty=frequency_penalty, tools=tools,
+                      tool_choice=tool_choice, response_format=response_format, reasoning_effort=reasoning_effort)
+        body = _chat_body(self._c, messages=messages, model=model, stream=stream, web_search=web_search,
+                          memory=memory, user=user, extra_body=extra_body, params=params)
+        if stream:
+            return Stream(self._c._send("POST", "/chat/completions", json=body, stream=True))
+        return ChatCompletion(self._c._send("POST", "/chat/completions", json=body).json())
+
+
+class Chat:
+    def __init__(self, client: "Locaith") -> None:
+        self.completions = Completions(client)
+
+
+class Models:
+    def __init__(self, client: "Locaith") -> None:
+        self._c = client
+
+    def list(self) -> List[AttrDict]:
+        return [AttrDict(m) for m in self._c._send("GET", "/models").json()["data"]]
+
+
+class Memory:
+    """Bio-Memory: ký ức dài hạn, mỗi API key (và mỗi user) một kho riêng."""
+
+    def __init__(self, client: "Locaith") -> None:
+        self._c = client
+
+    def list(self, *, user: Optional[str] = None) -> List[AttrDict]:
+        return [AttrDict(m) for m in self._c._send("GET", "/memory", params=_qs(self._c, user)).json()["items"]]
+
+    def add(self, title: str, content: str, *, type: str = "project", user: Optional[str] = None) -> str:
+        """type: user | feedback | project | reference. Trả về 'đã lưu' / 'trùng' / 'bị từ chối'."""
+        _check_type(type)
+        body = {"title": title, "content": content, "type": type, "user": user or self._c.user}
+        return self._c._send("POST", "/memory", json=body).json()["result"]
+
+    def delete(self, memory_id: str, *, user: Optional[str] = None) -> None:
+        self._c._send("DELETE", f"/memory/{memory_id}", params=_qs(self._c, user))
+
+    def export(self, path: Optional[str] = None, *, format: str = "zip", user: Optional[str] = None) -> Any:
+        """Xuất ký ức ra file. format: zip (mỗi ký ức một .md + MEMORY.md) | md | json.
+        Có path thì ghi file và trả về path; không có thì trả về bytes (json trả về dict)."""
+        r = self._c._send("GET", "/memory/export", params={"format": format, **_qs(self._c, user)})
+        if format == "json" and path is None:
+            return r.json()
+        if path is None:
+            return r.content
+        with open(path, "wb") as f:
+            f.write(r.content)
+        return path
+
+
+# ------------------------------------------------------------------ bất đồng bộ
+class AsyncCompletions:
+    def __init__(self, client: "AsyncLocaith") -> None:
+        self._c = client
+
+    async def create(
+        self,
+        *,
+        messages: Union[str, Iterable[Dict[str, Any]]],
+        model: str = DEFAULT_MODEL,
+        stream: bool = False,
+        web_search: bool = True,
+        memory: bool = False,
+        user: Optional[str] = None,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        stop: Union[str, List[str], None] = None,
+        seed: Optional[int] = None,
+        presence_penalty: Optional[float] = None,
+        frequency_penalty: Optional[float] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        tool_choice: Union[str, Dict[str, Any], None] = None,
+        response_format: Optional[Dict[str, Any]] = None,
+        reasoning_effort: Optional[str] = None,
+        extra_body: Optional[Dict[str, Any]] = None,
+    ) -> Union[ChatCompletion, AsyncStream]:
+        params = dict(temperature=temperature, top_p=top_p, max_tokens=max_tokens, stop=stop, seed=seed,
+                      presence_penalty=presence_penalty, frequency_penalty=frequency_penalty, tools=tools,
+                      tool_choice=tool_choice, response_format=response_format, reasoning_effort=reasoning_effort)
+        body = _chat_body(self._c, messages=messages, model=model, stream=stream, web_search=web_search,
+                          memory=memory, user=user, extra_body=extra_body, params=params)
+        if stream:
+            return AsyncStream(await self._c._send("POST", "/chat/completions", json=body, stream=True))
+        return ChatCompletion((await self._c._send("POST", "/chat/completions", json=body)).json())
+
+
+class AsyncChat:
+    def __init__(self, client: "AsyncLocaith") -> None:
+        self.completions = AsyncCompletions(client)
+
+
+class AsyncModels:
+    def __init__(self, client: "AsyncLocaith") -> None:
+        self._c = client
+
+    async def list(self) -> List[AttrDict]:
+        return [AttrDict(m) for m in (await self._c._send("GET", "/models")).json()["data"]]
+
+
+class AsyncMemory:
+    def __init__(self, client: "AsyncLocaith") -> None:
+        self._c = client
+
+    async def list(self, *, user: Optional[str] = None) -> List[AttrDict]:
+        r = await self._c._send("GET", "/memory", params=_qs(self._c, user))
+        return [AttrDict(m) for m in r.json()["items"]]
+
+    async def add(self, title: str, content: str, *, type: str = "project", user: Optional[str] = None) -> str:
+        _check_type(type)
+        body = {"title": title, "content": content, "type": type, "user": user or self._c.user}
+        return (await self._c._send("POST", "/memory", json=body)).json()["result"]
+
+    async def delete(self, memory_id: str, *, user: Optional[str] = None) -> None:
+        await self._c._send("DELETE", f"/memory/{memory_id}", params=_qs(self._c, user))
+
+    async def export(self, path: Optional[str] = None, *, format: str = "zip", user: Optional[str] = None) -> Any:
+        r = await self._c._send("GET", "/memory/export", params={"format": format, **_qs(self._c, user)})
+        if format == "json" and path is None:
+            return r.json()
+        if path is None:
+            return r.content
+        with open(path, "wb") as f:
+            f.write(r.content)
+        return path

locaith/_types.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import json
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional
+
+from ._errors import APIStatusError
+
+
+def _wrap(v: Any) -> Any:
+    if isinstance(v, dict) and not isinstance(v, AttrDict):
+        return AttrDict(v)
+    if isinstance(v, list):
+        return [_wrap(i) for i in v]
+    return v
+
+
+class AttrDict(dict):
+    """dict truy cập được bằng thuộc tính, giống đối tượng phản hồi của openai:
+    resp.choices[0].message.content. Trường không có trả về None."""
+
+    def __getattr__(self, name: str) -> Any:
+        if name.startswith("__"):
+            raise AttributeError(name)
+        return _wrap(self.get(name))
+
+    def __getitem__(self, key: str) -> Any:
+        return _wrap(super().__getitem__(key))
+
+    def to_dict(self) -> Dict[str, Any]:
+        return dict(self)
+
+
+class ChatCompletion(AttrDict):
+    """Phản hồi chat. Ngoài chuẩn OpenAI còn có .sources (nguồn web), .memory_hits, .checkpoint."""
+
+    @property
+    def text(self) -> str:
+        c = self.get("choices") or []
+        return ((c[0].get("message") or {}).get("content") or "") if c else ""
+
+    @property
+    def reasoning(self) -> str:
+        c = self.get("choices") or []
+        return ((c[0].get("message") or {}).get("reasoning") or "") if c else ""
+
+
+class ChatCompletionChunk(AttrDict):
+    pass
+
+
+class _StreamState:
+    def __init__(self) -> None:
+        self.sources: List[AttrDict] = []
+        self.memory_hits: int = 0
+        self.checkpoint: bool = False
+
+
+def parse_sse_line(line: str, state: _StreamState) -> Optional[ChatCompletionChunk]:
+    line = line.strip()
+    if not line.startswith("data:"):
+        return None
+    data = line[5:].strip()
+    if not data or data == "[DONE]":
+        return None
+    d = json.loads(data)
+    if "error" in d and not d.get("choices"):
+        raise APIStatusError(str((d["error"] or {}).get("message", "stream error")), status_code=500, body=d)
+    if not d.get("choices"):  # chunk đầu: nguồn web, số ký ức nhớ lại, điểm lưu
+        state.sources = [AttrDict(s) for s in d.get("sources") or []]
+        state.memory_hits = int(d.get("memory_hits") or 0)
+        state.checkpoint = bool(d.get("checkpoint"))
+        return None
+    return ChatCompletionChunk(d)
+
+
+class _StreamBase:
+    sources = property(lambda self: self._state.sources)
+    memory_hits = property(lambda self: self._state.memory_hits)
+    checkpoint = property(lambda self: self._state.checkpoint)
+
+
+class Stream(_StreamBase):
+    """Luồng chunk. for chunk in stream: ... hoặc for t in stream.text(): ...
+    Sau chunk đầu, stream.sources / .memory_hits / .checkpoint có giá trị."""
+
+    def __init__(self, response: Any) -> None:
+        self._r = response
+        self._state = _StreamState()
+
+    def __iter__(self) -> Iterator[ChatCompletionChunk]:
+        try:
+            for line in self._r.iter_lines():
+                ch = parse_sse_line(line, self._state)
+                if ch is not None:
+                    yield ch
+        finally:
+            self.close()
+
+    def text(self) -> Iterator[str]:
+        """Chỉ các đoạn chữ của câu trả lời."""
+        for ch in self:
+            t = ch.choices[0].delta.content
+            if t:
+                yield t
+
+    def close(self) -> None:
+        self._r.close()
+
+    def __enter__(self) -> "Stream":
+        return self
+
+    def __exit__(self, *a: Any) -> None:
+        self.close()
+
+
+class AsyncStream(_StreamBase):
+    def __init__(self, response: Any) -> None:
+        self._r = response
+        self._state = _StreamState()
+
+    async def __aiter__(self) -> AsyncIterator[ChatCompletionChunk]:
+        try:
+            async for line in self._r.aiter_lines():
+                ch = parse_sse_line(line, self._state)
+                if ch is not None:
+                    yield ch
+        finally:
+            await self.close()
+
+    async def text(self) -> AsyncIterator[str]:
+        async for ch in self:
+            t = ch.choices[0].delta.content
+            if t:
+                yield t
+
+    async def close(self) -> None:
+        await self._r.aclose()
+
+    async def __aenter__(self) -> "AsyncStream":
+        return self
+
+    async def __aexit__(self, *a: Any) -> None:
+        await self.close()

locaith/_version.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

locaith-1.0.0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.5
+Name: locaith
+Version: 1.0.0
+Summary: Python SDK cho Locaith-4-flash: tìm web, suy luận, ngữ cảnh 64K và Bio-Memory.
+Project-URL: Homepage, https://locaith.com
+Author: Locaith
+License: MIT
+License-File: LICENSE
+Keywords: ai,llm,locaith,openai-compatible,sdk,vietnamese
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: Vietnamese
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Requires-Dist: httpx<1,>=0.24
+Description-Content-Type: text/markdown
+
+# locaith
+
+Python SDK cho **Locaith-4-flash**: tìm web, suy luận, ngữ cảnh 64K, Bio-Memory.
+
+```bash
+pip install locaith
+export LOCAITH_API_KEY="LocAI..."
+```
+
+```python
+from locaith import Locaith
+
+client = Locaith()
+
+r = client.chat.completions.create(
+    messages=[{"role": "user", "content": "Giá vàng SJC hôm nay?"}],
+)
+print(r.choices[0].message.content)
+print([s.url for s in r.sources])
+```
+
+Streaming:
+
+```python
+stream = client.chat.completions.create(
+    messages=[{"role": "user", "content": "Viết bài 500 chữ về AI tại Việt Nam"}],
+    stream=True,
+)
+for text in stream.text():
+    print(text, end="", flush=True)
+print(stream.sources)
+```
+
+Bio-Memory:
+
+```python
+client = Locaith(user="khach_123")
+
+client.chat.completions.create(
+    messages=[{"role": "user", "content": "Tôi là kế toán trưởng công ty ABC."}],
+    memory=True,
+)
+client.chat.completions.create(
+    messages=[{"role": "user", "content": "Bạn nhớ tôi làm nghề gì?"}],
+    memory=True,
+)
+
+client.memory.list()
+client.memory.add("Quy ước báo cáo", "Đơn vị triệu đồng.", type="feedback")
+client.memory.export("ky-uc.zip")
+```
+
+Async:
+
+```python
+import asyncio
+from locaith import AsyncLocaith
+
+async def main():
+    async with AsyncLocaith() as client:
+        r = await client.chat.completions.create(messages="Xin chào")
+        print(r.text)
+
+asyncio.run(main())
+```
+
+Lỗi:
+
+```python
+import locaith
+
+try:
+    client.chat.completions.create(messages="Xin chào")
+except locaith.AuthenticationError as e:
+    print(e.status_code, e.message)
+except locaith.APIConnectionError:
+    ...
+```
+
+Tương thích OpenAI: có thể dùng thẳng SDK `openai` với `base_url="https://memory-api.locaith.com/v1"`.

locaith-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+locaith/__init__.py,sha256=qqgykytuj6wQ-RRZLHZfpy5ZO9r7Q5PuSueip-SKR6E,734
+locaith/_client.py,sha256=jqYIw9JoELaYKzUu7t-mejg1FVXXbG8owNI7mZwF6k0,7062
+locaith/_errors.py,sha256=bHY68V-S292P0Ee5ghvGL1iAxvVM5Cc_tKqKEpzgD_U,1615
+locaith/_resources.py,sha256=j4HltzIX1cJSn61c0vC4HD2Vd0QQ85K5fJ6mnAuPYNA,8715
+locaith/_types.py,sha256=AQ2mJaPuYhcte15XHvkwBqu5ght-oI2ZqiOQ_QOzbug,4330
+locaith/_version.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
+locaith/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+locaith-1.0.0.dist-info/METADATA,sha256=RiRIM7DQkv4oBFoHsoJI7hPiQkeNsZOe40356gTA2nM,2475
+locaith-1.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+locaith-1.0.0.dist-info/licenses/LICENSE,sha256=z83f5q00e6uNKQaJaLX2ExOKzKSu8Wdfq_YUoQFileU,1064
+locaith-1.0.0.dist-info/RECORD,,

locaith-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

locaith-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Locaith
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.