crewai-dakera 0.1.0__tar.gz

crewai_dakera-0.1.0/PKG-INFO

@@ -0,0 +1,250 @@
+Metadata-Version: 2.4
+Name: crewai-dakera
+Version: 0.1.0
+Summary: CrewAI integration for the Dakera AI memory platform
+Author: Dakera Team
+License: MIT
+Project-URL: Homepage, https://github.com/dakera-ai/dakera-crewai
+Project-URL: Documentation, https://docs.dakera.ai/integrations/crewai
+Project-URL: Repository, https://github.com/dakera-ai/dakera-crewai
+Keywords: crewai,dakera,memory,ai,agents
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: dakera>=0.9.0
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.30.0; extra == "crewai"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pip-audit>=2.0.0; extra == "dev"
+
+# crewai-dakera
+
+[![CI](https://github.com/Dakera-AI/dakera-crewai/actions/workflows/ci.yml/badge.svg)](https://github.com/Dakera-AI/dakera-crewai/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/crewai-dakera)](https://pypi.org/project/crewai-dakera/)
+[![Python](https://img.shields.io/pypi/pyversions/crewai-dakera)](https://pypi.org/project/crewai-dakera/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+**Persistent, semantically-recalled memory for [CrewAI](https://crewai.com) agents, powered by [Dakera](https://github.com/Dakera-AI/dakera-deploy).**
+
+Your CrewAI crews remember everything — across sessions, across restarts. Dakera handles embedding, storage, and retrieval server-side with no local model required.
+
+---
+
+## Quick Start
+
+### Step 1 — Run Dakera
+
+Dakera is a self-hosted memory server. Spin it up with Docker:
+
+```bash
+docker run -d \
+  --name dakera \
+  -p 3300:3300 \
+  -e DAKERA_ROOT_API_KEY=dk-mykey \
+  ghcr.io/dakera-ai/dakera:latest
+```
+
+For a production setup with persistent storage, use Docker Compose:
+
+```bash
+# Download and start
+curl -sSfL https://raw.githubusercontent.com/Dakera-AI/dakera-deploy/main/docker-compose.yml \
+  -o docker-compose.yml
+DAKERA_API_KEY=dk-mykey docker compose up -d
+
+# Verify it's running
+curl http://localhost:3300/health
+```
+
+> Full deployment guide: [github.com/Dakera-AI/dakera-deploy](https://github.com/Dakera-AI/dakera-deploy)
+
+### Step 2 — Install the integration
+
+```bash
+pip install crewai-dakera
+```
+
+### Step 3 — Add memory to your crew
+
+```python
+from crewai import Crew, Agent, Task
+from crewai.memory import LongTermMemory
+from crewai_dakera import DakeraStorage
+
+storage = DakeraStorage(
+    api_url="http://localhost:3300",
+    api_key="dk-mykey",
+    agent_id="my-crew",
+)
+
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    memory=True,
+    long_term_memory=LongTermMemory(storage=storage),
+)
+
+result = crew.kickoff(inputs={"topic": "AI trends"})
+```
+
+Your crew now persists everything it learns across runs.
+
+---
+
+## Installation
+
+```bash
+# Core + integration
+pip install crewai-dakera
+
+# With CrewAI (if not already installed)
+pip install "crewai-dakera[crewai]"
+```
+
+**Requirements:** Python ≥ 3.10, a running Dakera server (see Step 1 above)
+
+---
+
+## Configuration
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `api_url` | `str` | — | Dakera server URL (e.g. `http://localhost:3300`) |
+| `api_key` | `str` | `""` | API key set via `DAKERA_ROOT_API_KEY` |
+| `agent_id` | `str` | — | Logical identifier for this crew's memory |
+| `min_importance` | `float` | `0.0` | Minimum importance score for recalled memories |
+| `top_k` | `int` | `5` | Number of memories to surface per turn |
+
+Use environment variables to avoid hardcoding credentials:
+
+```python
+import os
+from crewai_dakera import DakeraStorage
+
+storage = DakeraStorage(
+    api_url=os.environ["DAKERA_URL"],
+    api_key=os.environ["DAKERA_API_KEY"],
+    agent_id="research-crew",
+)
+```
+
+---
+
+## Examples
+
+### Research crew with persistent memory
+
+```python
+from crewai import Agent, Task, Crew, Process
+from crewai.memory import LongTermMemory, ShortTermMemory, EntityMemory
+from crewai_dakera import DakeraStorage
+
+dakera = DakeraStorage(
+    api_url="http://localhost:3300",
+    api_key="dk-mykey",
+    agent_id="research-crew",
+)
+
+researcher = Agent(
+    role="Senior Researcher",
+    goal="Uncover groundbreaking insights in {topic}",
+    backstory="An expert researcher with decades of experience.",
+    verbose=True,
+)
+
+writer = Agent(
+    role="Content Writer",
+    goal="Craft compelling reports based on research findings",
+    backstory="A skilled writer who turns complex ideas into clear prose.",
+    verbose=True,
+)
+
+research_task = Task(
+    description="Research the latest developments in {topic}",
+    expected_output="A detailed research report",
+    agent=researcher,
+)
+
+write_task = Task(
+    description="Write a blog post based on the research",
+    expected_output="A polished 500-word article",
+    agent=writer,
+)
+
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research_task, write_task],
+    process=Process.sequential,
+    memory=True,
+    long_term_memory=LongTermMemory(storage=dakera),
+    verbose=True,
+)
+
+# First run — learns and stores findings
+result = crew.kickoff(inputs={"topic": "quantum computing"})
+print(result.raw)
+
+# Second run — recalls prior research automatically
+result = crew.kickoff(inputs={"topic": "quantum computing advances"})
+print(result.raw)
+```
+
+### Custom importance scoring
+
+```python
+storage = DakeraStorage(
+    api_url="http://localhost:3300",
+    api_key="dk-mykey",
+    agent_id="my-crew",
+    min_importance=0.6,  # only surface high-quality memories
+    top_k=10,
+)
+```
+
+---
+
+## How it works
+
+1. After each task, CrewAI calls `DakeraStorage.save()` with the result
+2. Dakera embeds the content server-side (no local model needed) and stores it with a semantic vector
+3. Before the next task, CrewAI calls `DakeraStorage.search()` — Dakera performs hybrid search (vector + BM25) and returns the most relevant past memories
+4. Memories decay gracefully over time based on access patterns — frequently-accessed memories stay prominent
+
+---
+
+## Related packages
+
+| Package | Framework | Language |
+|---------|-----------|----------|
+| `langchain-dakera` | LangChain | Python |
+| `llamaindex-dakera` | LlamaIndex | Python |
+| `autogen-dakera` | AutoGen | Python |
+| `@dakera-ai/langchain` | LangChain.js | TypeScript |
+
+---
+
+## Links
+
+- [Dakera Server](https://github.com/Dakera-AI/dakera-deploy) — self-hosted memory server
+- [Dakera Python SDK](https://github.com/Dakera-AI/dakera-py) — low-level API client
+- [Documentation](https://docs.dakera.ai/integrations/crewai)
+- [All integrations](https://github.com/Dakera-AI/dakera-integrations)
+
+---
+
+## License
+
+MIT © [Dakera AI](https://dakera.ai)

crewai_dakera-0.1.0/README.md

@@ -0,0 +1,218 @@
+# crewai-dakera
+
+[![CI](https://github.com/Dakera-AI/dakera-crewai/actions/workflows/ci.yml/badge.svg)](https://github.com/Dakera-AI/dakera-crewai/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/crewai-dakera)](https://pypi.org/project/crewai-dakera/)
+[![Python](https://img.shields.io/pypi/pyversions/crewai-dakera)](https://pypi.org/project/crewai-dakera/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+**Persistent, semantically-recalled memory for [CrewAI](https://crewai.com) agents, powered by [Dakera](https://github.com/Dakera-AI/dakera-deploy).**
+
+Your CrewAI crews remember everything — across sessions, across restarts. Dakera handles embedding, storage, and retrieval server-side with no local model required.
+
+---
+
+## Quick Start
+
+### Step 1 — Run Dakera
+
+Dakera is a self-hosted memory server. Spin it up with Docker:
+
+```bash
+docker run -d \
+  --name dakera \
+  -p 3300:3300 \
+  -e DAKERA_ROOT_API_KEY=dk-mykey \
+  ghcr.io/dakera-ai/dakera:latest
+```
+
+For a production setup with persistent storage, use Docker Compose:
+
+```bash
+# Download and start
+curl -sSfL https://raw.githubusercontent.com/Dakera-AI/dakera-deploy/main/docker-compose.yml \
+  -o docker-compose.yml
+DAKERA_API_KEY=dk-mykey docker compose up -d
+
+# Verify it's running
+curl http://localhost:3300/health
+```
+
+> Full deployment guide: [github.com/Dakera-AI/dakera-deploy](https://github.com/Dakera-AI/dakera-deploy)
+
+### Step 2 — Install the integration
+
+```bash
+pip install crewai-dakera
+```
+
+### Step 3 — Add memory to your crew
+
+```python
+from crewai import Crew, Agent, Task
+from crewai.memory import LongTermMemory
+from crewai_dakera import DakeraStorage
+
+storage = DakeraStorage(
+    api_url="http://localhost:3300",
+    api_key="dk-mykey",
+    agent_id="my-crew",
+)
+
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    memory=True,
+    long_term_memory=LongTermMemory(storage=storage),
+)
+
+result = crew.kickoff(inputs={"topic": "AI trends"})
+```
+
+Your crew now persists everything it learns across runs.
+
+---
+
+## Installation
+
+```bash
+# Core + integration
+pip install crewai-dakera
+
+# With CrewAI (if not already installed)
+pip install "crewai-dakera[crewai]"
+```
+
+**Requirements:** Python ≥ 3.10, a running Dakera server (see Step 1 above)
+
+---
+
+## Configuration
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `api_url` | `str` | — | Dakera server URL (e.g. `http://localhost:3300`) |
+| `api_key` | `str` | `""` | API key set via `DAKERA_ROOT_API_KEY` |
+| `agent_id` | `str` | — | Logical identifier for this crew's memory |
+| `min_importance` | `float` | `0.0` | Minimum importance score for recalled memories |
+| `top_k` | `int` | `5` | Number of memories to surface per turn |
+
+Use environment variables to avoid hardcoding credentials:
+
+```python
+import os
+from crewai_dakera import DakeraStorage
+
+storage = DakeraStorage(
+    api_url=os.environ["DAKERA_URL"],
+    api_key=os.environ["DAKERA_API_KEY"],
+    agent_id="research-crew",
+)
+```
+
+---
+
+## Examples
+
+### Research crew with persistent memory
+
+```python
+from crewai import Agent, Task, Crew, Process
+from crewai.memory import LongTermMemory, ShortTermMemory, EntityMemory
+from crewai_dakera import DakeraStorage
+
+dakera = DakeraStorage(
+    api_url="http://localhost:3300",
+    api_key="dk-mykey",
+    agent_id="research-crew",
+)
+
+researcher = Agent(
+    role="Senior Researcher",
+    goal="Uncover groundbreaking insights in {topic}",
+    backstory="An expert researcher with decades of experience.",
+    verbose=True,
+)
+
+writer = Agent(
+    role="Content Writer",
+    goal="Craft compelling reports based on research findings",
+    backstory="A skilled writer who turns complex ideas into clear prose.",
+    verbose=True,
+)
+
+research_task = Task(
+    description="Research the latest developments in {topic}",
+    expected_output="A detailed research report",
+    agent=researcher,
+)
+
+write_task = Task(
+    description="Write a blog post based on the research",
+    expected_output="A polished 500-word article",
+    agent=writer,
+)
+
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research_task, write_task],
+    process=Process.sequential,
+    memory=True,
+    long_term_memory=LongTermMemory(storage=dakera),
+    verbose=True,
+)
+
+# First run — learns and stores findings
+result = crew.kickoff(inputs={"topic": "quantum computing"})
+print(result.raw)
+
+# Second run — recalls prior research automatically
+result = crew.kickoff(inputs={"topic": "quantum computing advances"})
+print(result.raw)
+```
+
+### Custom importance scoring
+
+```python
+storage = DakeraStorage(
+    api_url="http://localhost:3300",
+    api_key="dk-mykey",
+    agent_id="my-crew",
+    min_importance=0.6,  # only surface high-quality memories
+    top_k=10,
+)
+```
+
+---
+
+## How it works
+
+1. After each task, CrewAI calls `DakeraStorage.save()` with the result
+2. Dakera embeds the content server-side (no local model needed) and stores it with a semantic vector
+3. Before the next task, CrewAI calls `DakeraStorage.search()` — Dakera performs hybrid search (vector + BM25) and returns the most relevant past memories
+4. Memories decay gracefully over time based on access patterns — frequently-accessed memories stay prominent
+
+---
+
+## Related packages
+
+| Package | Framework | Language |
+|---------|-----------|----------|
+| `langchain-dakera` | LangChain | Python |
+| `llamaindex-dakera` | LlamaIndex | Python |
+| `autogen-dakera` | AutoGen | Python |
+| `@dakera-ai/langchain` | LangChain.js | TypeScript |
+
+---
+
+## Links
+
+- [Dakera Server](https://github.com/Dakera-AI/dakera-deploy) — self-hosted memory server
+- [Dakera Python SDK](https://github.com/Dakera-AI/dakera-py) — low-level API client
+- [Documentation](https://docs.dakera.ai/integrations/crewai)
+- [All integrations](https://github.com/Dakera-AI/dakera-integrations)
+
+---
+
+## License
+
+MIT © [Dakera AI](https://dakera.ai)

crewai_dakera-0.1.0/pyproject.toml

@@ -0,0 +1,59 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "crewai-dakera"
+version = "0.1.0"
+description = "CrewAI integration for the Dakera AI memory platform"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "Dakera Team"}]
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Typing :: Typed",
+]
+keywords = ["crewai", "dakera", "memory", "ai", "agents"]
+dependencies = ["dakera>=0.9.0"]
+
+[project.optional-dependencies]
+crewai = ["crewai>=0.30.0"]
+dev = ["pytest>=7.0.0", "pytest-asyncio>=0.21.0", "ruff>=0.1.0", "mypy>=1.0.0", "pip-audit>=2.0.0"]
+
+[project.urls]
+Homepage = "https://github.com/dakera-ai/dakera-crewai"
+Documentation = "https://docs.dakera.ai/integrations/crewai"
+Repository = "https://github.com/dakera-ai/dakera-crewai"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+crewai_dakera = ["py.typed"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP"]
+
+[tool.mypy]
+python_version = "3.10"
+ignore_missing_imports = true
+check_untyped_defs = true
+warn_return_any = true
+warn_unused_ignores = true

crewai_dakera-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

crewai_dakera-0.1.0/src/crewai_dakera/__init__.py

@@ -0,0 +1,4 @@
+from crewai_dakera.storage import DakeraStorage
+
+__all__ = ["DakeraStorage"]
+__version__ = "0.1.0"

crewai_dakera-0.1.0/src/crewai_dakera/storage.py

@@ -0,0 +1,32 @@
+"""DakeraStorage — CrewAI storage backed by the Dakera AI memory platform."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from dakera import DakeraClient
+
+
+class DakeraStorage:
+    """Persistent semantic storage for CrewAI agents backed by Dakera AI."""
+
+    def __init__(self, api_url: str, agent_id: str, api_key: str = "",
+                 search_k: int = 5, min_importance: float = 0.0, importance: float = 0.7) -> None:
+        self._client = DakeraClient(api_url, api_key=api_key)
+        self._agent_id = agent_id
+        self._search_k = search_k
+        self._min_importance = min_importance
+        self._importance = importance
+
+    def save(self, value: str, metadata: dict[str, Any] | None = None) -> None:
+        self._client.store_memory(self._agent_id, content=value, memory_type="episodic",
+                                  importance=self._importance, metadata=metadata or {})
+
+    def search(self, query: str, limit: int | None = None) -> list[dict[str, Any]]:
+        k = limit if limit is not None else self._search_k
+        min_imp = self._min_importance if self._min_importance > 0.0 else None
+        memories = self._client.recall(self._agent_id, query=query, top_k=k, min_importance=min_imp)
+        return [{"content": m.content, "id": m.id, "score": m.score} for m in memories.memories]
+
+    def reset(self) -> None:
+        """No-op: Dakera memories are persistent by design."""

crewai_dakera-0.1.0/src/crewai_dakera.egg-info/PKG-INFO

@@ -0,0 +1,250 @@
+Metadata-Version: 2.4
+Name: crewai-dakera
+Version: 0.1.0
+Summary: CrewAI integration for the Dakera AI memory platform
+Author: Dakera Team
+License: MIT
+Project-URL: Homepage, https://github.com/dakera-ai/dakera-crewai
+Project-URL: Documentation, https://docs.dakera.ai/integrations/crewai
+Project-URL: Repository, https://github.com/dakera-ai/dakera-crewai
+Keywords: crewai,dakera,memory,ai,agents
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: dakera>=0.9.0
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.30.0; extra == "crewai"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pip-audit>=2.0.0; extra == "dev"
+
+# crewai-dakera
+
+[![CI](https://github.com/Dakera-AI/dakera-crewai/actions/workflows/ci.yml/badge.svg)](https://github.com/Dakera-AI/dakera-crewai/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/crewai-dakera)](https://pypi.org/project/crewai-dakera/)
+[![Python](https://img.shields.io/pypi/pyversions/crewai-dakera)](https://pypi.org/project/crewai-dakera/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+**Persistent, semantically-recalled memory for [CrewAI](https://crewai.com) agents, powered by [Dakera](https://github.com/Dakera-AI/dakera-deploy).**
+
+Your CrewAI crews remember everything — across sessions, across restarts. Dakera handles embedding, storage, and retrieval server-side with no local model required.
+
+---
+
+## Quick Start
+
+### Step 1 — Run Dakera
+
+Dakera is a self-hosted memory server. Spin it up with Docker:
+
+```bash
+docker run -d \
+  --name dakera \
+  -p 3300:3300 \
+  -e DAKERA_ROOT_API_KEY=dk-mykey \
+  ghcr.io/dakera-ai/dakera:latest
+```
+
+For a production setup with persistent storage, use Docker Compose:
+
+```bash
+# Download and start
+curl -sSfL https://raw.githubusercontent.com/Dakera-AI/dakera-deploy/main/docker-compose.yml \
+  -o docker-compose.yml
+DAKERA_API_KEY=dk-mykey docker compose up -d
+
+# Verify it's running
+curl http://localhost:3300/health
+```
+
+> Full deployment guide: [github.com/Dakera-AI/dakera-deploy](https://github.com/Dakera-AI/dakera-deploy)
+
+### Step 2 — Install the integration
+
+```bash
+pip install crewai-dakera
+```
+
+### Step 3 — Add memory to your crew
+
+```python
+from crewai import Crew, Agent, Task
+from crewai.memory import LongTermMemory
+from crewai_dakera import DakeraStorage
+
+storage = DakeraStorage(
+    api_url="http://localhost:3300",
+    api_key="dk-mykey",
+    agent_id="my-crew",
+)
+
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    memory=True,
+    long_term_memory=LongTermMemory(storage=storage),
+)
+
+result = crew.kickoff(inputs={"topic": "AI trends"})
+```
+
+Your crew now persists everything it learns across runs.
+
+---
+
+## Installation
+
+```bash
+# Core + integration
+pip install crewai-dakera
+
+# With CrewAI (if not already installed)
+pip install "crewai-dakera[crewai]"
+```
+
+**Requirements:** Python ≥ 3.10, a running Dakera server (see Step 1 above)
+
+---
+
+## Configuration
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `api_url` | `str` | — | Dakera server URL (e.g. `http://localhost:3300`) |
+| `api_key` | `str` | `""` | API key set via `DAKERA_ROOT_API_KEY` |
+| `agent_id` | `str` | — | Logical identifier for this crew's memory |
+| `min_importance` | `float` | `0.0` | Minimum importance score for recalled memories |
+| `top_k` | `int` | `5` | Number of memories to surface per turn |
+
+Use environment variables to avoid hardcoding credentials:
+
+```python
+import os
+from crewai_dakera import DakeraStorage
+
+storage = DakeraStorage(
+    api_url=os.environ["DAKERA_URL"],
+    api_key=os.environ["DAKERA_API_KEY"],
+    agent_id="research-crew",
+)
+```
+
+---
+
+## Examples
+
+### Research crew with persistent memory
+
+```python
+from crewai import Agent, Task, Crew, Process
+from crewai.memory import LongTermMemory, ShortTermMemory, EntityMemory
+from crewai_dakera import DakeraStorage
+
+dakera = DakeraStorage(
+    api_url="http://localhost:3300",
+    api_key="dk-mykey",
+    agent_id="research-crew",
+)
+
+researcher = Agent(
+    role="Senior Researcher",
+    goal="Uncover groundbreaking insights in {topic}",
+    backstory="An expert researcher with decades of experience.",
+    verbose=True,
+)
+
+writer = Agent(
+    role="Content Writer",
+    goal="Craft compelling reports based on research findings",
+    backstory="A skilled writer who turns complex ideas into clear prose.",
+    verbose=True,
+)
+
+research_task = Task(
+    description="Research the latest developments in {topic}",
+    expected_output="A detailed research report",
+    agent=researcher,
+)
+
+write_task = Task(
+    description="Write a blog post based on the research",
+    expected_output="A polished 500-word article",
+    agent=writer,
+)
+
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research_task, write_task],
+    process=Process.sequential,
+    memory=True,
+    long_term_memory=LongTermMemory(storage=dakera),
+    verbose=True,
+)
+
+# First run — learns and stores findings
+result = crew.kickoff(inputs={"topic": "quantum computing"})
+print(result.raw)
+
+# Second run — recalls prior research automatically
+result = crew.kickoff(inputs={"topic": "quantum computing advances"})
+print(result.raw)
+```
+
+### Custom importance scoring
+
+```python
+storage = DakeraStorage(
+    api_url="http://localhost:3300",
+    api_key="dk-mykey",
+    agent_id="my-crew",
+    min_importance=0.6,  # only surface high-quality memories
+    top_k=10,
+)
+```
+
+---
+
+## How it works
+
+1. After each task, CrewAI calls `DakeraStorage.save()` with the result
+2. Dakera embeds the content server-side (no local model needed) and stores it with a semantic vector
+3. Before the next task, CrewAI calls `DakeraStorage.search()` — Dakera performs hybrid search (vector + BM25) and returns the most relevant past memories
+4. Memories decay gracefully over time based on access patterns — frequently-accessed memories stay prominent
+
+---
+
+## Related packages
+
+| Package | Framework | Language |
+|---------|-----------|----------|
+| `langchain-dakera` | LangChain | Python |
+| `llamaindex-dakera` | LlamaIndex | Python |
+| `autogen-dakera` | AutoGen | Python |
+| `@dakera-ai/langchain` | LangChain.js | TypeScript |
+
+---
+
+## Links
+
+- [Dakera Server](https://github.com/Dakera-AI/dakera-deploy) — self-hosted memory server
+- [Dakera Python SDK](https://github.com/Dakera-AI/dakera-py) — low-level API client
+- [Documentation](https://docs.dakera.ai/integrations/crewai)
+- [All integrations](https://github.com/Dakera-AI/dakera-integrations)
+
+---
+
+## License
+
+MIT © [Dakera AI](https://dakera.ai)

crewai_dakera-0.1.0/src/crewai_dakera.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/crewai_dakera/__init__.py
+src/crewai_dakera/py.typed
+src/crewai_dakera/storage.py
+src/crewai_dakera.egg-info/PKG-INFO
+src/crewai_dakera.egg-info/SOURCES.txt
+src/crewai_dakera.egg-info/dependency_links.txt
+src/crewai_dakera.egg-info/requires.txt
+src/crewai_dakera.egg-info/top_level.txt
+tests/test_storage.py

crewai_dakera-0.1.0/src/crewai_dakera.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

crewai_dakera-0.1.0/src/crewai_dakera.egg-info/requires.txt

@@ -0,0 +1,11 @@
+dakera>=0.9.0
+
+[crewai]
+crewai>=0.30.0
+
+[dev]
+pytest>=7.0.0
+pytest-asyncio>=0.21.0
+ruff>=0.1.0
+mypy>=1.0.0
+pip-audit>=2.0.0

crewai_dakera-0.1.0/src/crewai_dakera.egg-info/top_level.txt

@@ -0,0 +1 @@
+crewai_dakera

crewai_dakera-0.1.0/tests/test_storage.py

@@ -0,0 +1,55 @@
+"""Tests for DakeraStorage (CrewAI integration)."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from crewai_dakera import DakeraStorage
+
+
+@pytest.fixture
+def storage():
+    with patch("crewai_dakera.storage.DakeraClient") as MockClient:
+        mock_client = MagicMock()
+        MockClient.return_value = mock_client
+        s = DakeraStorage(api_url="http://localhost:3000", api_key="test-key",
+                          agent_id="crew-1", search_k=3)
+        s._client = mock_client
+        yield s, mock_client
+
+
+def test_save_stores_memory(storage):
+    s, mock_client = storage
+    s.save("Client prefers weekly status reports")
+    mock_client.store_memory.assert_called_once_with(
+        "crew-1", content="Client prefers weekly status reports",
+        memory_type="episodic", importance=0.7, metadata={})
+
+
+def test_search_returns_memories(storage):
+    s, mock_client = storage
+    mem = MagicMock(content="Client prefers weekly status reports", id="m-1", score=0.9)
+    mock_recall = MagicMock()
+    mock_recall.memories = [mem]
+    mock_client.recall.return_value = mock_recall
+    results = s.search("What does the client want?")
+    assert len(results) == 1
+    assert results[0]["content"] == "Client prefers weekly status reports"
+    mock_client.recall.assert_called_once_with(
+        "crew-1", query="What does the client want?", top_k=3, min_importance=None)
+
+
+def test_search_wraps_non_dict_results(storage):
+    s, mock_client = storage
+    mem = MagicMock(content="plain string memory", id="m-2", score=0.8)
+    mock_recall = MagicMock()
+    mock_recall.memories = [mem]
+    mock_client.recall.return_value = mock_recall
+    results = s.search("test")
+    assert results[0]["content"] == "plain string memory"
+
+
+def test_reset_is_noop(storage):
+    s, mock_client = storage
+    s.reset()
+    mock_client.forget.assert_not_called()