sovant 1.0.0__py3-none-any.whl → 1.0.3__py3-none-any.whl

sovant/__init__.py

@@ -1,63 +1,4 @@
-"""
-Sovant Python SDK
+from .client import Sovant, SovantError
+from .models import MemoryCreate, MemoryResult, SearchQuery
 
-Official Python library for the Sovant Memory API.
-"""
-
-__version__ = "1.0.0"
-
-from .client import SovantClient, AsyncSovantClient
-from .exceptions import (
-    SovantError,
-    AuthenticationError,
-    RateLimitError,
-    ValidationError,
-    NotFoundError,
-    NetworkError,
-)
-from .types import (
-    Memory,
-    MemoryType,
-    EmotionType,
-    EmotionalContext,
-    CreateMemoryInput,
-    UpdateMemoryInput,
-    SearchOptions,
-    SearchResult,
-    Thread,
-    ThreadStatus,
-    CreateThreadInput,
-    UpdateThreadInput,
-    ThreadStats,
-    BatchCreateResult,
-    PaginatedResponse,
-)
-
-__all__ = [
-    # Client classes
-    "SovantClient",
-    "AsyncSovantClient",
-    # Exceptions
-    "SovantError",
-    "AuthenticationError",
-    "RateLimitError",
-    "ValidationError",
-    "NotFoundError",
-    "NetworkError",
-    # Types
-    "Memory",
-    "MemoryType",
-    "EmotionType",
-    "EmotionalContext",
-    "CreateMemoryInput",
-    "UpdateMemoryInput",
-    "SearchOptions",
-    "SearchResult",
-    "Thread",
-    "ThreadStatus",
-    "CreateThreadInput",
-    "UpdateThreadInput",
-    "ThreadStats",
-    "BatchCreateResult",
-    "PaginatedResponse",
-]
+__version__ = "0.1.0"

sovant/client.py

@@ -1,87 +1,90 @@
-"""Main client for the Sovant SDK."""
+import os
+import json
+import httpx
+from typing import Any, Dict
+from .models import MemoryCreate, SearchQuery
 
-from typing import Any, Dict, Union
+class SovantError(Exception):
+    def __init__(self, message: str, code: str, status: int | None = None, details: Any | None = None):
+        super().__init__(message)
+        self.code = code
+        self.status = status
+        self.details = details
 
-from .base_client import AsyncBaseClient, BaseClient
-from .resources import AsyncMemories, AsyncThreads, Memories, Threads
-from .types import Config
+class Sovant:
+    def __init__(self, api_key: str | None = None, base_url: str | None = None, timeout: float = 30.0):
+        self.api_key = api_key or os.getenv("SOVANT_API_KEY")
+        if not self.api_key:
+            raise ValueError("Missing api_key")
+        self.base_url = (base_url or os.getenv("SOVANT_BASE_URL") or "https://api.sovant.ai").rstrip("/")
+        self.timeout = timeout
+        self._client = httpx.Client(
+            timeout=self.timeout,
+            headers={
+                "authorization": f"Bearer {self.api_key}",
+                "content-type": "application/json"
+            }
+        )
 
+    def _handle(self, r: httpx.Response):
+        if r.status_code >= 400:
+            try:
+                body = r.json()
+            except Exception:
+                body = {"message": r.text}
+            msg = body.get("message") or r.reason_phrase
+            code = body.get("code") or f"HTTP_{r.status_code}"
+            raise SovantError(msg, code, r.status_code, body)
+        if not r.text:
+            return None
+        try:
+            return r.json()
+        except Exception:
+            return r.text
 
-class SovantClient:
-    """Synchronous client for the Sovant API."""
-    
-    def __init__(self, api_key: Union[str, Config, None] = None):
-        """
-        Initialize the Sovant client.
+    def memory_create(self, create: MemoryCreate):
+        # Convert data field to content field for API
+        body = create.model_dump()
+        if 'data' in body:
+            body['content'] = json.dumps(body.pop('data')) if not isinstance(body.get('data'), str) else body.pop('data')
         
-        Args:
-            api_key: API key string, Config object, or None (uses env var)
-        """
-        if api_key is None:
-            import os
-            api_key = os.environ.get("SOVANT_API_KEY", "")
-        
-        if isinstance(api_key, str):
-            config = Config(api_key=api_key)
-        else:
-            config = api_key
-        
-        self.memories = Memories(config)
-        self.threads = Threads(config)
-        self._config = config
-    
-    def ping(self) -> Dict[str, str]:
-        """Test API connection."""
-        client = BaseClient(self._config)
-        return client.request("GET", "/health")
-    
-    def get_usage(self) -> Dict[str, Any]:
-        """Get current API usage and quota."""
-        client = BaseClient(self._config)
-        return client.request("GET", "/usage")
+        # Ensure type has a default
+        if 'type' not in body or body['type'] is None:
+            body['type'] = 'journal'
+            
+        r = self._client.post(f"{self.base_url}/v1/memory", content=json.dumps(body))
+        return self._handle(r)
 
+    def memory_get(self, id: str):
+        r = self._client.get(f"{self.base_url}/v1/memories/{id}")
+        return self._handle(r)
 
-class AsyncSovantClient:
-    """Asynchronous client for the Sovant API."""
-    
-    def __init__(self, api_key: Union[str, Config, None] = None):
-        """
-        Initialize the async Sovant client.
-        
-        Args:
-            api_key: API key string, Config object, or None (uses env var)
-        """
-        if api_key is None:
-            import os
-            api_key = os.environ.get("SOVANT_API_KEY", "")
-        
-        if isinstance(api_key, str):
-            config = Config(api_key=api_key)
-        else:
-            config = api_key
-        
-        self.memories = AsyncMemories(config)
-        self.threads = AsyncThreads(config)
-        self._config = config
-    
-    async def ping(self) -> Dict[str, str]:
-        """Test API connection."""
-        async with AsyncBaseClient(self._config) as client:
-            return await client.request("GET", "/health")
-    
-    async def get_usage(self) -> Dict[str, Any]:
-        """Get current API usage and quota."""
-        async with AsyncBaseClient(self._config) as client:
-            return await client.request("GET", "/usage")
-    
-    async def __aenter__(self):
-        """Context manager entry."""
-        return self
-    
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit."""
-        # Clean up any open connections
-        if hasattr(self.memories, "client"):
-            await self.memories.client.aclose()
-        if hasattr(self.threads, "client"):
-            await self.threads.client.aclose()
+    def memory_search(self, q: SearchQuery):
+        params = {}
+        if q.query:
+            params['query'] = q.query
+        if q.type:
+            params['type'] = q.type
+        if q.tags:
+            params['tags'] = ','.join(q.tags)
+        if q.thread_id:
+            params['thread_id'] = q.thread_id
+        if q.limit:
+            params['limit'] = str(q.limit)
+        if q.from_date:
+            params['from_date'] = q.from_date
+        if q.to_date:
+            params['to_date'] = q.to_date
+        r = self._client.get(f"{self.base_url}/v1/memory/search", params=params)
+        return self._handle(r)
+
+    def memory_update(self, id: str, patch: Dict[str, Any]):
+        # Convert data field to content field if present
+        if 'data' in patch:
+            patch['content'] = json.dumps(patch.pop('data')) if not isinstance(patch.get('data'), str) else patch.pop('data')
+        r = self._client.patch(f"{self.base_url}/v1/memories/{id}", content=json.dumps(patch))
+        return self._handle(r)
+
+    def memory_delete(self, id: str):
+        r = self._client.delete(f"{self.base_url}/v1/memories/{id}")
+        return self._handle(r)

sovant/models.py

@@ -0,0 +1,30 @@
+from pydantic import BaseModel, Field
+from typing import Any, Dict, List, Optional, Literal
+
+class MemoryCreate(BaseModel):
+    data: Any
+    type: Optional[Literal['journal', 'insight', 'observation', 'task', 'preference']] = 'journal'
+    ttl: Optional[str] = None
+    tags: Optional[List[str]] = None
+    metadata: Optional[Dict[str, Any]] = None
+    thread_id: Optional[str] = None
+
+class MemoryResult(BaseModel):
+    id: str
+    content: str
+    type: str
+    ttl: Optional[str] = None
+    tags: Optional[List[str]] = None
+    metadata: Optional[Dict[str, Any]] = None
+    thread_id: Optional[str] = None
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+
+class SearchQuery(BaseModel):
+    query: Optional[str] = None
+    type: Optional[str] = None
+    tags: Optional[List[str]] = None
+    thread_id: Optional[str] = None
+    limit: Optional[int] = Field(default=10, ge=1, le=100)
+    from_date: Optional[str] = None
+    to_date: Optional[str] = None

sovant-1.0.3.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: sovant
+Version: 1.0.3
+Summary: Sovant Memory-as-a-Service Python SDK
+Author: Sovant
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.8.2
+Dynamic: license-file
+
+# Sovant Python SDK
+
+**AI Infrastructure: Memory-as-a-Service for AI systems.**  
+The official Python client for the Sovant Memory API.
+
+[![PyPI version](https://img.shields.io/pypi/v/sovant)](https://pypi.org/project/sovant/)
+[![Documentation](https://img.shields.io/badge/docs-sovant.ai-blue)](https://sovant.ai/docs)
+[![GitHub](https://img.shields.io/badge/github-sovant-lightgrey)](https://github.com/sovant-ai/sovant)
+
+---
+
+## What is Sovant?
+
+Sovant is an **AI infrastructure company** providing the **memory layer for AI systems**.  
+Our platform makes it simple to persist, search, and manage conversational/context data securely across sessions, channels, and applications.
+
+- **Problem:** Most AI systems forget once a session ends → compliance risk, knowledge loss, poor UX.  
+- **Solution:** Sovant provides a **Memory-as-a-Service API** — store, retrieve, and search memories with audit-ready controls.  
+- **Built for:** Developers & enterprises building AI agents, copilots, or compliance-driven apps that need persistent context.
+
+---
+
+## Installation
+
+```bash
+pip install sovant
+```
+
+## 60-Second Quickstart
+
+```python
+from sovant import Sovant, MemoryCreate, SearchQuery
+
+client = Sovant(api_key="YOUR_API_KEY")
+
+# Create a memory
+created = client.memory_create(MemoryCreate(
+    content="User prefers morning meetings",
+    type="preference",
+    tags=["customer:123"],
+    # metadata={"source": "crm"},
+    # thread_id="00000000-0000-0000-0000-000000000000",
+))
+print(created)
+
+# Search memories
+results = client.memory_search(SearchQuery(
+    query="meeting preferences",
+    topK=3,
+    # tags=["customer:123"],
+    # thread_id="...",
+))
+print(results)
+```
+
+## Features
+
+- **Memory CRUD** — create, retrieve, update (PATCH/PUT), delete
+- **Semantic Search** — full-text/semantic with topK and filters
+- **Threads** — group related memories via thread_id (REST API)
+- **Batch Operations (Beta)** — atomic multi-operation requests
+- **Compliance-ready** — audit trails, PDPA/GDPR-friendly design
+- **SDKs** — official Python & TypeScript clients + REST reference
+
+## SDKs & Documentation
+
+- **Python** (this package) on PyPI: https://pypi.org/project/sovant/
+- **TypeScript** on npm: https://www.npmjs.com/package/@sovant/sdk
+- **REST API Reference**: https://sovant.ai/docs/api
+- **Full Documentation**: https://sovant.ai/docs
+
+## API Overview
+
+### Endpoints Summary
+
+- `POST /api/v1/memory` — Create memory
+- `GET /api/v1/memory` — List memories
+- `GET /api/v1/memories/{id}` — Get by ID
+- `PATCH | PUT /api/v1/memories/{id}` — Update
+- `DELETE /api/v1/memories/{id}` — Delete
+- `GET /api/v1/memory/search` — Search
+- `POST /api/v1/memory/batch` — Batch (Beta)
+
+**Auth:** Bearer token in the `Authorization` header.
+
+## Field Mapping Note
+
+- **API expects:** `content` (required), optional `type`, `tags`, `metadata`, `thread_id`.
+- **SDK convenience:** Some client methods may accept `data` and map it to `content` internally.
+- **Deprecated:** `subject` is ignored by the API. Use `thread_id`, `tags`, or `metadata` for grouping.
+
+## Status of Advanced Features
+
+- **Batch API:** Available, marked Beta (contract may evolve).
+- **Threads:** Fully supported via REST API.
+- **Webhooks / Personalization / Multi-Channel Sync:** Coming soon.
+
+## Versioning & Changelog
+
+- **Stable baseline:** 1.0.3
+- See [CHANGELOG.md](https://github.com/sovant-ai/sovant) in the repo for details.
+
+## License
+
+MIT © Sovant AI

sovant-1.0.3.dist-info/RECORD

@@ -0,0 +1,14 @@
+sovant/__init__.py,sha256=1GYQzmb1Ni5-y874HOs1J-rYrpx-iBzR4_cCEBFIjpk,122
+sovant/base_client.py,sha256=Vmn6OGywGwLbH5cEeflSjVOFwn5iX_YdfTdUq9pWWxA,8778
+sovant/client.py,sha256=QmcUnK_IFXIE9VbvNy3VeI8rsGeeJpLkUvB-721VNBY,3356
+sovant/exceptions.py,sha256=MQMSgk7ckXnAbe7hPPpbKOnRBHSPxuCY7WSjqfJAvd0,1557
+sovant/models.py,sha256=avDAITMptDDdDfNH_ed854Q7kF6z_1OzjwJ9Xeft_-8,979
+sovant/types.py,sha256=gnvdXksJt8LObti7nc6eHSBCB7Pz7SNpS5o_HRTq_kA,6098
+sovant/resources/__init__.py,sha256=cPFIM7h8duviDdeHudnVEAmv3F89RHQxdH5BCRWFteQ,193
+sovant/resources/memories.py,sha256=bKKE0uWqFkPa1OEvbK1LrdSD7v6N04RhJ_2VDoPPQBA,11379
+sovant/resources/threads.py,sha256=mN29xP0JODmZBKyfhpeqJyViUWNVMAx3TlYAW-1ruTs,12558
+sovant-1.0.3.dist-info/licenses/LICENSE,sha256=rnNP6-elrMIlQ9jf2aqnHZMyyQ_wvF3y1hTpVUusCWU,1062
+sovant-1.0.3.dist-info/METADATA,sha256=ul2TZUpPijkKMc0ySZn7goqy_5VDzFuj-y7KzZI5zew,3757
+sovant-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sovant-1.0.3.dist-info/top_level.txt,sha256=za6eVEsYd_ZQQs8vrmEWNcAR58r1wCDge_jA60e4CvQ,7
+sovant-1.0.3.dist-info/RECORD,,

{sovant-1.0.0.dist-info → sovant-1.0.3.dist-info}/licenses/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Sovant AI
+Copyright (c) 2025 Sovant
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

sovant-1.0.0.dist-info/METADATA

@@ -1,492 +0,0 @@
-Metadata-Version: 2.4
-Name: sovant
-Version: 1.0.0
-Summary: Official Python SDK for Sovant Memory API
-Author-email: Sovant AI <support@sovant.ai>
-License: MIT License
-        
-        Copyright (c) 2024 Sovant AI
-        
-        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.
-Project-URL: Homepage, https://sovant.ai
-Project-URL: Documentation, https://docs.sovant.ai
-Project-URL: Repository, https://github.com/sovant-ai/python-sdk
-Project-URL: Issues, https://github.com/sovant-ai/python-sdk/issues
-Keywords: sovant,memory,api,ai,sdk
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: httpx>=0.25.0
-Requires-Dist: pydantic>=2.0.0
-Requires-Dist: python-dateutil>=2.8.0
-Provides-Extra: async
-Requires-Dist: httpx[http2]; extra == "async"
-Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
-Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
-Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
-Requires-Dist: black>=23.0.0; extra == "dev"
-Requires-Dist: mypy>=1.0.0; extra == "dev"
-Requires-Dist: ruff>=0.1.0; extra == "dev"
-Dynamic: license-file
-
-# Sovant Python SDK
-
-Official Python SDK for the Sovant Memory API. Build AI applications with persistent memory, semantic search, and intelligent context management.
-
-> **Note: Coming Soon!** This SDK is currently in development and will be available on PyPI soon. In the meantime, you can use our REST API directly.
-
-## Installation
-
-```bash
-# Coming soon
-pip install sovant
-```
-
-For async support:
-
-```bash
-# Coming soon
-pip install sovant[async]
-```
-
-## Quick Start
-
-```python
-from sovant import SovantClient
-
-# Initialize the client
-client = SovantClient(api_key="YOUR_API_KEY")
-
-# Create a memory
-memory = client.memories.create({
-    "content": "User prefers Python for data science projects",
-    "type": "preference",
-    "metadata": {
-        "confidence": 0.95,
-        "context": "programming_languages"
-    }
-})
-
-print(f"Created memory: {memory.id}")
-
-# Search memories
-results = client.memories.search({
-    "query": "What programming languages does the user prefer?",
-    "limit": 5
-})
-
-for result in results:
-    print(f"- {result.content} (relevance: {result.relevance_score:.2f})")
-```
-
-## Features
-
-- 🐍 **Full Type Hints** - Complete type annotations for better IDE support
-- 🔄 **Async/Await Support** - Built for modern Python applications
-- 🔁 **Automatic Retries** - Configurable retry logic with exponential backoff
-- 📦 **Batch Operations** - Efficient bulk create/delete operations
-- 🎯 **Smart Search** - Semantic, keyword, and hybrid search modes
-- 🧵 **Thread Management** - Organize memories into contextual threads
-- 📊 **Analytics** - Built-in insights and statistics
-- 🛡️ **Comprehensive Error Handling** - Typed exceptions for all error cases
-
-## Configuration
-
-```python
-from sovant import SovantClient, Config
-
-# Using configuration object
-config = Config(
-    api_key="YOUR_API_KEY",
-    base_url="https://api.sovant.ai/v1",  # Optional
-    timeout=30,  # Request timeout in seconds
-    max_retries=3,  # Number of retries for failed requests
-    retry_delay=1.0  # Initial delay between retries
-)
-
-client = SovantClient(config)
-```
-
-You can also use environment variables:
-
-```bash
-export SOVANT_API_KEY="YOUR_API_KEY"
-```
-
-```python
-from sovant import SovantClient
-
-# Automatically reads from SOVANT_API_KEY env var
-client = SovantClient()
-```
-
-## Memory Operations
-
-### Create a Memory
-
-```python
-from sovant import MemoryType, EmotionType
-
-memory = client.memories.create({
-    "content": "User completed the onboarding tutorial",
-    "type": MemoryType.EVENT,
-    "importance": 0.8,
-    "metadata": {
-        "step_completed": "tutorial",
-        "duration_seconds": 180
-    },
-    "tags": ["onboarding", "milestone"],
-    "emotion": {
-        "type": EmotionType.POSITIVE,
-        "intensity": 0.7
-    },
-    "action_items": ["Send welcome email", "Unlock advanced features"]
-})
-```
-
-### Update a Memory
-
-```python
-updated = client.memories.update(memory.id, {
-    "importance": 0.9,
-    "follow_up_required": True,
-    "follow_up_due": "2024-12-31T23:59:59Z"
-})
-```
-
-### Search Memories
-
-```python
-# Semantic search
-semantic_results = client.memories.search({
-    "query": "user achievements and milestones",
-    "search_type": "semantic",
-    "limit": 10
-})
-
-# Filtered search
-from sovant import MemoryType
-
-filtered_results = client.memories.search({
-    "query": "preferences",
-    "type": [MemoryType.PREFERENCE, MemoryType.DECISION],
-    "tags": ["important"],
-    "created_after": "2024-01-01",
-    "sort_by": "importance",
-    "sort_order": "desc"
-})
-```
-
-### Batch Operations
-
-```python
-# Batch create
-memories_data = [
-    {"content": "User is a data scientist", "type": "observation"},
-    {"content": "User works with ML models", "type": "learning"},
-    {"content": "User prefers Jupyter notebooks", "type": "preference"}
-]
-
-batch_result = client.memories.create_batch(memories_data)
-print(f"Created {batch_result.success_count} memories")
-print(f"Failed {batch_result.failed_count} memories")
-
-# Batch delete
-result = client.memories.delete_batch(["mem_123", "mem_456", "mem_789"])
-print(f"Deleted {result['deleted']} memories")
-```
-
-## Thread Management
-
-### Create a Thread
-
-```python
-thread = client.threads.create({
-    "name": "Customer Support Chat",
-    "description": "Tracking customer issues and resolutions",
-    "tags": ["support", "customer", "priority"]
-})
-```
-
-### Add Memories to Thread
-
-```python
-# Add existing memories
-client.threads.add_memories(thread.id, [memory1.id, memory2.id])
-
-# Create and add in one operation
-new_memory = client.memories.create({
-    "content": "Customer reported login issue",
-    "type": "conversation",
-    "thread_ids": [thread.id]
-})
-```
-
-### Get Thread with Memories
-
-```python
-# Get thread with all memories included
-thread_with_memories = client.threads.get(thread.id, include_memories=True)
-
-print(f"Thread: {thread_with_memories.name}")
-print(f"Total memories: {len(thread_with_memories.memories)}")
-
-for memory in thread_with_memories.memories:
-    print(f"- {memory.content}")
-```
-
-### Thread Analytics
-
-```python
-stats = client.threads.get_stats(thread.id)
-
-print(f"Total memories: {stats.memory_count}")
-print(f"Average importance: {stats.avg_importance:.2f}")
-print(f"Decisions made: {stats.total_decisions}")
-print(f"Open questions: {stats.total_questions}")
-print(f"Action items: {stats.total_action_items}")
-```
-
-## Async Support
-
-```python
-import asyncio
-from sovant import AsyncSovantClient
-
-async def main():
-    # Use async client for better performance
-    async with AsyncSovantClient(api_key="YOUR_API_KEY") as client:
-        # Create multiple memories concurrently
-        memories = await asyncio.gather(
-            client.memories.create({"content": "Memory 1"}),
-            client.memories.create({"content": "Memory 2"}),
-            client.memories.create({"content": "Memory 3"})
-        )
-
-        print(f"Created {len(memories)} memories")
-
-        # Async search
-        results = await client.memories.search({
-            "query": "user preferences",
-            "search_type": "semantic"
-        })
-
-        for result in results:
-            print(f"- {result.content}")
-
-asyncio.run(main())
-```
-
-## Error Handling
-
-The SDK provides typed exceptions for different error scenarios:
-
-```python
-from sovant import (
-    AuthenticationError,
-    RateLimitError,
-    ValidationError,
-    NotFoundError,
-    NetworkError
-)
-
-try:
-    memory = client.memories.get("invalid_id")
-except NotFoundError:
-    print("Memory not found")
-except RateLimitError as e:
-    print(f"Rate limited. Retry after {e.retry_after} seconds")
-except ValidationError as e:
-    print(f"Validation errors: {e.errors}")
-except AuthenticationError:
-    print("Invalid API key")
-except NetworkError:
-    print("Network error occurred")
-```
-
-## Advanced Usage
-
-### Memory Insights
-
-```python
-insights = client.memories.get_insights(
-    time_range="last_30_days",
-    group_by="type"
-)
-
-print(f"Total memories: {insights['total_count']}")
-print(f"Type distribution: {insights['type_distribution']}")
-print(f"Emotion distribution: {insights['emotion_distribution']}")
-print(f"Average importance: {insights['importance_stats']['avg']}")
-print(f"Growth rate: {insights['growth_rate']}%")
-```
-
-### Related Memories
-
-```python
-# Find memories related to a specific memory
-related = client.memories.get_related(
-    memory_id=memory.id,
-    limit=5,
-    threshold=0.7  # Minimum similarity score
-)
-
-for r in related:
-    print(f"- {r.content} (similarity: {r.relevance_score:.2f})")
-```
-
-### Thread Operations
-
-```python
-# Archive a thread
-archived = client.threads.archive(thread.id)
-
-# Search threads
-threads = client.threads.search(
-    query="customer support",
-    status="active",
-    tags=["priority"]
-)
-
-# Merge threads
-merged = client.threads.merge(
-    target_id=main_thread.id,
-    source_ids=[thread2.id, thread3.id]
-)
-
-# Clone a thread
-cloned = client.threads.clone(
-    thread_id=thread.id,
-    name="Cloned Thread",
-    include_memories=True
-)
-```
-
-### Pagination
-
-```python
-# List memories with pagination
-page1 = client.memories.list(limit=20, offset=0)
-print(f"Total memories: {page1.total}")
-print(f"Has more: {page1.has_more}")
-
-# Get next page
-if page1.has_more:
-    page2 = client.memories.list(limit=20, offset=20)
-```
-
-## Type Safety
-
-The SDK uses Pydantic for data validation and provides enums for better type safety:
-
-```python
-from sovant import MemoryType, EmotionType, ThreadStatus
-
-# Using enums ensures valid values
-memory = client.memories.create({
-    "content": "Important decision made",
-    "type": MemoryType.DECISION,  # Type-safe enum
-    "emotion": {
-        "type": EmotionType.NEUTRAL,  # Type-safe enum
-        "intensity": 0.5
-    }
-})
-
-# IDE will provide autocompletion for all fields
-thread = client.threads.create({
-    "name": "Project Planning",
-    "status": ThreadStatus.ACTIVE  # Type-safe enum
-})
-```
-
-## Best Practices
-
-1. **Use batch operations for bulk actions**
-
-   ```python
-   # Good - single API call
-   batch_result = client.memories.create_batch(memories_list)
-
-   # Avoid - multiple API calls
-   for memory_data in memories_list:
-       client.memories.create(memory_data)
-   ```
-
-2. **Use async client for concurrent operations**
-
-   ```python
-   async with AsyncSovantClient() as client:
-       results = await asyncio.gather(*tasks)
-   ```
-
-3. **Handle errors gracefully**
-
-   ```python
-   try:
-       result = client.memories.search({"query": "test"})
-   except RateLimitError as e:
-       await asyncio.sleep(e.retry_after)
-       # Retry the request
-   ```
-
-4. **Use type hints for better IDE support**
-
-   ```python
-   from sovant import Memory, SearchResult
-
-   def process_memory(memory: Memory) -> None:
-       print(f"Processing {memory.id}")
-
-   def handle_results(results: list[SearchResult]) -> None:
-       for result in results:
-           print(f"Score: {result.relevance_score}")
-   ```
-
-## Examples
-
-Check out the [examples directory](https://github.com/sovant-ai/python-sdk/tree/main/examples) for complete working examples:
-
-- Basic CRUD operations
-- Advanced search techniques
-- Thread management workflows
-- Async patterns
-- Error handling
-- Data analysis with pandas integration
-
-## Support
-
-- 📚 [Documentation](https://docs.sovant.ai)
-- 💬 [Discord Community](https://discord.gg/sovant)
-- 🐛 [Issue Tracker](https://github.com/sovant-ai/python-sdk/issues)
-- 📧 [Email Support](mailto:support@sovant.ai)
-
-## License
-
-MIT © Sovant AI

sovant-1.0.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-sovant/__init__.py,sha256=1MoHw4tAMuMjBUakVz6qXqFgKf37ijZVveSOB6wcXwE,1174
-sovant/base_client.py,sha256=Vmn6OGywGwLbH5cEeflSjVOFwn5iX_YdfTdUq9pWWxA,8778
-sovant/client.py,sha256=C71f9tFfbpQAkw5yjOfalNeCPwOqu9M5FyNzuittOAU,2763
-sovant/exceptions.py,sha256=MQMSgk7ckXnAbe7hPPpbKOnRBHSPxuCY7WSjqfJAvd0,1557
-sovant/types.py,sha256=gnvdXksJt8LObti7nc6eHSBCB7Pz7SNpS5o_HRTq_kA,6098
-sovant/resources/__init__.py,sha256=cPFIM7h8duviDdeHudnVEAmv3F89RHQxdH5BCRWFteQ,193
-sovant/resources/memories.py,sha256=bKKE0uWqFkPa1OEvbK1LrdSD7v6N04RhJ_2VDoPPQBA,11379
-sovant/resources/threads.py,sha256=mN29xP0JODmZBKyfhpeqJyViUWNVMAx3TlYAW-1ruTs,12558
-sovant-1.0.0.dist-info/licenses/LICENSE,sha256=Z_4cIqcf0pj97wNZqUXZgynU_gwhNzriM5u3HzlzFzM,1065
-sovant-1.0.0.dist-info/METADATA,sha256=jOe4BqtU1QYbscc59vLCl1d-76wo9wCfCltyyS__GjE,13179
-sovant-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sovant-1.0.0.dist-info/top_level.txt,sha256=za6eVEsYd_ZQQs8vrmEWNcAR58r1wCDge_jA60e4CvQ,7
-sovant-1.0.0.dist-info/RECORD,,