@@ -39,6 +39,8 @@ Add a conversation; EverOS turns it into structured, retrievable memory you can
 - **Structured memory, not chat logs** — extracts episodes, user profiles, and reusable
   agent cases & skills from raw conversations, so retrieval returns meaning, not transcripts.
 - **Retrieval that fits the query** — keyword, vector, hybrid (default), or agentic multi-step search.
+- **Knowledge bases** — ingest documents into a searchable topic library alongside
+  conversational memory; ingest is async and reports progress through the task API.
 - **Multimodal** — attach images, audio, and documents to any message.
 - **Built for production** — fully managed (no vector DB or extraction pipeline to run),
   with low-latency retrieval and high-concurrency throughput. The engineering guarantees
@@ -74,9 +76,39 @@ with EverOS(api_key="sk-...") as client:
     print(results)
 ```
 
-**Full usage** — every memory operation, profile editing, and multimodal upload — is in
+Knowledge bases work the same way — ingest is asynchronous, so wait on the task:
+
+```python
+kb   = client.kb_create("Employee Handbook")
+ack  = client.doc_ingest(kb.id, "Leave policy", "Employees accrue 20 days...")
+task = client.task_wait(ack.task_id)          # polls until the document is queryable
+
+hits = client.kb_search(kb.id, "how much leave do I get")
+```
+
+**Full usage** — every memory operation, knowledge base, async task, profile editing, and
+multimodal upload — is in
 **[quickstart.md](https://github.com/EverMind-AI/everos-cloud-sdk-python/blob/v1/quickstart.md)**.
-Prefer typed control? The generated low-level client is exposed as `client.memory` / `client.storage`.
+
+### Two ways to call the API
+
+`EverOS` covers the common calls with plain kwargs in and the response's `.data` out.
+New methods are named `<resource>_<verb>` (`kb_create`, `doc_ingest`, `task_wait`,
+`tag_bind`), so typing `client.kb` lists the knowledge-base surface; the methods 1.0.0
+shipped are bare verbs (`add`, `search`, `get`, `flush`, `edit`, `delete`, `upload`).
+
+Everything the API offers — all 31 operations, including knowledge-base categories and
+document topics — is on the generated typed clients, reachable as `client.memory`,
+`client.storage`, `client.knowledge`, `client.tasks`. Those take and return the full
+typed models, so responses arrive as an envelope you read `.data` from. The
+per-endpoint reference for them is under
+[`docs/`](https://github.com/EverMind-AI/everos-cloud-sdk-python/tree/v1/docs).
+
+```python
+client.kb_create("Handbook")                          # facade   -> KbData
+client.knowledge.create_knowledge_base({"name": "…"})  # generated -> envelope, .data
+client.knowledge.list_topics(kb_id, doc_id)            # generated only
+```
 
 ## Documentation
 
 
@@ -11,10 +11,13 @@
     client.add(session_id="s1", messages=[{"role": "user", "content": "I love hiking"}])
     hits = client.search("outdoor hobbies")
 
-Naming: memory is the unprefixed default (``add`` / ``search`` / ``get`` / ``flush`` /
-``edit`` / ``delete``, frozen since 1.0.0); every other resource carries its own prefix
-— ``kb_`` / ``doc_`` / ``task_`` / ``tag_`` — so an editor's completion list groups by
-resource, and no facade method collides with the generated method it wraps.
+Naming: the nine methods 1.0.0 shipped are bare verbs and stay that way — ``add`` /
+``search`` / ``get`` / ``flush`` / ``edit`` / ``delete`` (memory), ``presign`` /
+``upload`` (storage), ``close``. They are public API and cannot be renamed. Everything
+added since carries its resource as a prefix — ``kb_`` / ``doc_`` / ``task_`` /
+``tag_`` — so completion groups by resource and no facade method collides with the
+generated method it wraps. The two styles sitting side by side is a consequence of that
+freeze, not a convention worth copying.
 
 Errors: every failure raised by this facade derives from :class:`EverOSError` —
 ``EverOSAPIError`` for HTTP errors, ``EverOSStorageError`` for object-upload failures,
@@ -69,6 +72,26 @@
 # on one blip is worse than useless — the caller has no way to resume it.
 _TRANSIENT_STATUS = frozenset({429, 500, 502, 503, 504})
 
+# Generated method name -> the facade method that covers it. Used only to answer an
+# AttributeError helpfully: the generated per-endpoint docs (docs/*.md) are the largest
+# body of documentation and they describe ONLY the generated clients, so a reader who
+# arrives from there types `client.create_knowledge_base(...)` and would otherwise get a
+# bare AttributeError with nowhere to go.
+_FACADE_FOR = {
+    "add_memory": "add", "search_memory": "search", "get_memory": "get",
+    "flush_memory": "flush", "edit_profile": "edit", "delete_memory": "delete",
+    "sign_objects": "presign",
+    "bind_tags": "tag_bind", "unbind_tags": "tag_unbind", "replace_tags": "tag_replace",
+    "create_knowledge_base": "kb_create", "list_knowledge_bases": "kb_list",
+    "get_knowledge_base": "kb_get", "update_knowledge_base": "kb_update",
+    "delete_knowledge_base": "kb_delete", "search_knowledge": "kb_search",
+    "create_document": "doc_ingest", "replace_document": "doc_ingest",
+    "list_documents": "doc_list", "get_document": "doc_get",
+    "update_document": "doc_update", "delete_document": "doc_delete",
+    "get_task_status": "task_get", "list_tasks": "task_list",
+}
+_API_ATTRS = ("memory", "storage", "knowledge", "tasks")
+
 # Statuses the gateway reports as finished. Deliberately paired with a `finished_at`
 # check in `_task_finished`: `status` is an OPEN set on a response field (a new
 # terminal state such as `cancelled` must not make `task_wait` spin until timeout),
@@ -174,6 +197,26 @@ def __init__(
         self._project_id = project_id
         self._timeout = timeout
 
+    def __getattr__(self, name: str) -> Any:
+        """Point a generated method name at where it actually lives.
+
+        Python calls this only after normal lookup fails, so it costs nothing on the
+        happy path. Reads ``__dict__`` directly rather than ``getattr`` to stay safe
+        during ``__init__`` and to avoid recursing through itself.
+        """
+        for attr in _API_ATTRS:
+            api = self.__dict__.get(attr)
+            if api is not None and hasattr(api, name):
+                facade = _FACADE_FOR.get(name)
+                hint = f"The facade covers it as `client.{facade}(...)`. " if facade else ""
+                raise AttributeError(
+                    f"{type(self).__name__!r} has no attribute {name!r} — that is a "
+                    f"generated method name, not a facade one. {hint}"
+                    f"The generated client is at `client.{attr}.{name}(...)`, which "
+                    f"returns the response envelope rather than its `.data`."
+                )
+        raise AttributeError(f"{type(self).__name__!r} object has no attribute {name!r}")
+
     # -- lifecycle -----------------------------------------------------------
     def __enter__(self) -> "EverOS":
         return self
 
@@ -143,9 +143,11 @@ context manager (`with EverOS(...) as client:`) to release connections on exit.
 
 ## Method reference
 
-Facade methods are named `<resource>_<verb>`, so typing `client.kb` / `client.doc` /
-`client.task` / `client.tag` lists everything for that resource. The six memory methods
-carry no prefix — an unprefixed verb always means memory.
+New facade methods are named `<resource>_<verb>`, so typing `client.kb` / `client.doc` /
+`client.task` / `client.tag` lists everything for that resource. The nine methods 1.0.0
+shipped are bare verbs with no prefix (`add` / `search` / `get` / `flush` / `edit` /
+`delete` for memory, `presign` / `upload` for storage, plus `close`) — that split is
+historical, not a rule: those names are public API since 1.0.0 and cannot be changed.
 
 | Method | Endpoint | Notes |
 |---|---|---|
 
@@ -667,3 +667,40 @@ def test_search_kb_does_materialize_its_defaults():
     c.kb_search("kb-1", "q")
     body = kb.search_knowledge.call_args.args[1].to_dict()
     assert body["method"] == "hybrid" and body["top_k"] == 10
+
+
+# ── discovery: a generated name typed on the facade must say where to go ─────
+def test_generated_name_on_the_facade_points_at_the_real_one():
+    """docs/*.md documents only the generated clients, so readers arrive with those
+    names. A bare AttributeError leaves them stuck; this one carries the answer."""
+    c = EverOS("sk-test")
+
+    with pytest.raises(AttributeError) as ei:
+        c.create_knowledge_base
+    msg = str(ei.value)
+    assert "client.kb_create" in msg                          # facade equivalent
+    assert "client.knowledge.create_knowledge_base" in msg    # generated location
+
+    # a generated method the facade does NOT cover: still says where it lives
+    with pytest.raises(AttributeError) as ei:
+        c.list_topics
+    assert "client.knowledge.list_topics" in str(ei.value)
+    assert "facade covers it" not in str(ei.value)
+
+    # a genuinely unknown attribute stays an ordinary AttributeError
+    with pytest.raises(AttributeError) as ei:
+        c.totally_bogus
+    assert "generated method name" not in str(ei.value)
+
+
+def test_getattr_hook_does_not_break_normal_lookup():
+    c = EverOS("sk-test")
+    assert hasattr(c, "kb_create") and hasattr(c, "knowledge")
+    assert not hasattr(c, "nope")
+    # Dunders that copy/pickle probe for must fall through to a PLAIN AttributeError,
+    # never be answered with the generated-name hint. (`__getstate__` is not in this
+    # list: object gained a real one in 3.11, so it resolves before __getattr__ runs.)
+    for dunder in ("__deepcopy__", "__copy__", "__reduce_ex__x"):
+        with pytest.raises(AttributeError) as ei:
+            getattr(c, dunder)
+        assert "generated method name" not in str(ei.value)