synapse-memory-engine 1.3.0__tar.gz → 1.3.1__tar.gz

{synapse_memory_engine-1.3.0 → synapse_memory_engine-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synapse-memory-engine
-Version: 1.3.0
+Version: 1.3.1
 Summary: Production-grade active RAG & cognitive memory engine with multi-tenancy, pgvector HNSW indexing, semantic deduplication, decay-based pruning, and token-aware context packing.
 Home-page: https://github.com/721189/Synapse-Memory
 Author: Synapse Cognitive Systems
@@ -49,7 +49,7 @@ Dynamic: requires-python
 
 # Synapse Memory Python SDK
 
-Core Python SDK and algorithms for the Synapse Cognitive Memory substrate.
+Python distribution for the Synapse Memory engine. The distribution name is `synapse-memory-engine`; the import package is `synapse_memory`.
 
 ## Features
 
@@ -68,8 +68,34 @@ pip install synapse-memory-engine          # from PyPI
 pip install -e .
 ```
 
+## REST client quick start
+
+Use `SynapseClient` when connecting an application to a running Synapse API:
+
+```python
+from synapse_memory import SynapseClient, SynapseError
+
+with SynapseClient(
+    "http://127.0.0.1:8008",
+    api_key="syn_live_your_key",
+    tenant_id="your-tenant",
+) as client:
+    created = client.create_memory("Customer selected the annual plan.", category="fact")
+    result = client.retrieve("Which plan did the customer select?")
+    print(created.id, result.fused_context)
+```
+
+The client automatically retries idempotent `GET`/`HEAD`/`OPTIONS` requests and honours `Retry-After`. It does not automatically replay `POST` requests (including `/query`, which updates access metadata) after an ambiguous failure; callers should reconcile the operation before manually retrying, or provide their own idempotency mechanism.
+
 ## Testing
 
+From the repository root:
+
 ```bash
-python3 -m unittest discover -s tests
+pip install -e "sdk/python[pgvector,langchain,llamaindex,dev]"
+PYTHONPATH=sdk/python pytest sdk/python/tests -v
 ```
+
+Database-gated tests require a disposable PostgreSQL/pgvector database and explicitly documented environment flags. Passing the offline suite alone is not production verification.
+
+**Licence:** proprietary. Installation does not grant unrestricted usage or deployment rights; obtain written permission under [`../../LICENSE`](../../LICENSE) before using this package outside the permissions granted by the copyright holder.

synapse_memory_engine-1.3.1/README.md

@@ -0,0 +1,52 @@
+# Synapse Memory Python SDK
+
+Python distribution for the Synapse Memory engine. The distribution name is `synapse-memory-engine`; the import package is `synapse_memory`.
+
+## Features
+
+- **Encrypted SQLite Storage**: Fernet AES-128-CBC with HMAC-SHA256 authenticated encryption at rest.
+- **Dynamic Programming Knapsack Packing**: Exact 0/1 Knapsack optimizer for packing high-relevance memories into strict token envelopes.
+- **Ebbinghaus Decay Engine**: Continuous temporal decay with positive/negative reinforcement factors.
+- **Semantic Deduplication**: Dual lexical Jaccard and dense cosine similarity detection to prevent node fragmentation.
+- **Hybrid Retrieval**: BM25 sparse lexical ranking fused with dense vector embeddings via Reciprocal Rank Fusion (RRF).
+- **Framework Integrations**: True drop-in adapters for LangChain (`BaseMemory`) and LlamaIndex (`BaseMemory`).
+
+## Installation
+
+```bash
+pip install synapse-memory-engine          # from PyPI
+# or, from a checkout of this repository:
+pip install -e .
+```
+
+## REST client quick start
+
+Use `SynapseClient` when connecting an application to a running Synapse API:
+
+```python
+from synapse_memory import SynapseClient, SynapseError
+
+with SynapseClient(
+    "http://127.0.0.1:8008",
+    api_key="syn_live_your_key",
+    tenant_id="your-tenant",
+) as client:
+    created = client.create_memory("Customer selected the annual plan.", category="fact")
+    result = client.retrieve("Which plan did the customer select?")
+    print(created.id, result.fused_context)
+```
+
+The client automatically retries idempotent `GET`/`HEAD`/`OPTIONS` requests and honours `Retry-After`. It does not automatically replay `POST` requests (including `/query`, which updates access metadata) after an ambiguous failure; callers should reconcile the operation before manually retrying, or provide their own idempotency mechanism.
+
+## Testing
+
+From the repository root:
+
+```bash
+pip install -e "sdk/python[pgvector,langchain,llamaindex,dev]"
+PYTHONPATH=sdk/python pytest sdk/python/tests -v
+```
+
+Database-gated tests require a disposable PostgreSQL/pgvector database and explicitly documented environment flags. Passing the offline suite alone is not production verification.
+
+**Licence:** proprietary. Installation does not grant unrestricted usage or deployment rights; obtain written permission under [`../../LICENSE`](../../LICENSE) before using this package outside the permissions granted by the copyright holder.

{synapse_memory_engine-1.3.0 → synapse_memory_engine-1.3.1}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 # owned by an unrelated third-party project. Import package stays `synapse_memory`.
 # See docs/publishing.md.
 name = "synapse-memory-engine"
-version = "1.3.0"
+version = "1.3.1"
 authors = [{name = "Synapse Cognitive Systems", email = "singhshivam20009@gmail.com"}]
 description = "Production-grade active RAG & cognitive memory engine with multi-tenancy, pgvector HNSW indexing, semantic deduplication, decay-based pruning, and token-aware context packing."
 readme = "README.md"

{synapse_memory_engine-1.3.0 → synapse_memory_engine-1.3.1}/setup.py

@@ -2,10 +2,10 @@ from setuptools import setup, find_packages
 
 setup(
     name="synapse-memory-engine",
-    version="1.2.0",
+    version="1.3.1",
     description="Sovereign, active RAG & cognitive long-term memory engine for AI agents",
     author="Synapse Cognitive Systems",
-    author_email="synapse-memory@users.noreply.github.com",
+    author_email="singhshivam20009@gmail.com",
     url="https://github.com/721189/Synapse-Memory",
     license="All Rights Reserved",
     packages=find_packages(include=["synapse_memory*"]),
@@ -16,6 +16,7 @@ setup(
         "uvicorn>=0.34.0",
         "cryptography>=42.0.0",
         "requests>=2.31.0",
+        "urllib3>=2.8.0",
         "numpy>=1.26.0",
     ],
     extras_require={
@@ -29,13 +30,13 @@ setup(
             "pgvector>=0.4.0",
             "langchain-core>=0.3.0",
             "llama-index-core>=0.13.0",
+            "redis>=5.0.0",
         ],
         "dev": [
             "flake8>=7.0.0",
             "mypy>=1.13.0",
             "bandit>=1.8.0",
             "pytest>=8.0.0",
-            "types-cryptography>=42.0.0",
             "types-requests>=2.32.0",
         ],
     },

{synapse_memory_engine-1.3.0 → synapse_memory_engine-1.3.1}/synapse_memory/__init__.py

@@ -10,7 +10,7 @@ from synapse_memory.integrations.langchain import SynapseLangChainMemory
 from synapse_memory.integrations.llamaindex import SynapseLlamaIndexMemory
 from synapse_memory.client import SynapseClient, SynapseError, CreateResult, QueryResult
 
-__version__ = "1.3.0"
+__version__ = "1.3.1"
 __api_compat_version__ = "v1"
 
 __all__ = [

{synapse_memory_engine-1.3.0 → synapse_memory_engine-1.3.1}/synapse_memory/api/fastapi_server.py

@@ -6,7 +6,7 @@ import hashlib
 import logging
 import threading
 from typing import List, Dict, Any, Optional, Tuple
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 import uvicorn
 from fastapi import FastAPI, HTTPException, status, Header, Request, Depends
 from fastapi.middleware.cors import CORSMiddleware
@@ -233,7 +233,7 @@ def _rate_limit_principal(request: Request) -> str:
 app = FastAPI(
     title="SynapseMemory Enterprise Cognitive Gateway",
     description="Sovereign Active Long-Term Memory & Context Budgeting REST API with Multi-Tenancy and Database-Level RLS.",
-    version="1.2.0"
+    version="1.3.1"
 )
 
 
@@ -415,21 +415,32 @@ def envelope(data: Any, request: Optional[Request] = None) -> Dict[str, Any]:
 
 # --- PYDANTIC SCHEMAS ---
 
-class IngestRequest(BaseModel):
+class SynapseAPIModel(BaseModel):
+    """Request/response models accept canonical aliases and Python field names.
+
+    Clients in Python naturally serialize fields as snake_case (tenant_id,
+    max_token_budget), while the public JSON API also documents camelCase aliases
+    (tenantId, maxTokens). Pydantic otherwise silently ignores the snake_case key
+    when an alias is configured, which can silently change a request's tenant.
+    """
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class IngestRequest(SynapseAPIModel):
     content: str = Field(..., min_length=1, max_length=32000, description="Raw text representation of the memory segment")
     category: str = Field("interaction", min_length=1, max_length=64, pattern=r"^[a-z0-9_\-]+$", description="Cognitive category (e.g., interaction, preference, system)")
     confidence: float = Field(0.95, ge=0.0, le=1.0, description="Confidence alignment coefficient")
     tenant_id: Optional[str] = Field(None, alias="tenantId", min_length=1, max_length=128, pattern=r"^[A-Za-z0-9_\-\.]+$", description="Target tenant ID for isolation")
 
 
-class IngestResponse(BaseModel):
+class IngestResponse(SynapseAPIModel):
     id: str
     status: str
     token_cost: int
     tenant_id: str
 
 
-class QueryRequest(BaseModel):
+class QueryRequest(SynapseAPIModel):
     prompt: Optional[str] = Field(None, min_length=1, max_length=8000, description="Active user prompt")
     query: Optional[str] = Field(None, min_length=1, max_length=8000, description="Alternative alias for prompt")
     max_token_budget: int = Field(1500, ge=50, le=8000, description="Max token window allowed for context packing", alias="maxTokens")
@@ -437,20 +448,20 @@ class QueryRequest(BaseModel):
     tenant_id: Optional[str] = Field(None, alias="tenantId", min_length=1, max_length=128, pattern=r"^[A-Za-z0-9_\-\.]+$", description="Target tenant ID")
 
 
-class QueryResponse(BaseModel):
+class QueryResponse(SynapseAPIModel):
     fused_context: str
     injected_nodes_count: int
     injected_nodes: List[Dict[str, Any]]
     active_storage_backend: str
 
 
-class FeedbackRequest(BaseModel):
+class FeedbackRequest(SynapseAPIModel):
     memory_id: str = Field(..., min_length=1, max_length=256, description="Memory node ID")
     feedback_type: str = Field(..., pattern=r"^(positive|negative)$", description="Must be either 'positive' (boost) or 'negative' (hallucination alert)")
     tenant_id: Optional[str] = Field(None, alias="tenantId", min_length=1, max_length=128, pattern=r"^[A-Za-z0-9_\-\.]+$")
 
 
-class CreateKeyRequest(BaseModel):
+class CreateKeyRequest(SynapseAPIModel):
     name: str = Field(..., min_length=1, max_length=128)
     organization_id: str = Field("org_default", min_length=1, max_length=128, pattern=r"^[A-Za-z0-9_\-\.]+$")
     project_id: str = Field("proj_default", min_length=1, max_length=128, pattern=r"^[A-Za-z0-9_\-\.]+$")
@@ -467,7 +478,7 @@ class CreateKeyRequest(BaseModel):
     ttl_days: Optional[int] = Field(365, ge=1, le=3650)
 
 
-class RevokeKeyRequest(BaseModel):
+class RevokeKeyRequest(SynapseAPIModel):
     key_id: str = Field(..., min_length=1, max_length=128)
 
 
@@ -1079,7 +1090,7 @@ def prune_audit_trail(
     return envelope({"deleted": deleted, "older_than_days": days}, request)
 
 
-class RotateKeyRequest(BaseModel):
+class RotateKeyRequest(SynapseAPIModel):
     key_id: str
 
 
@@ -1135,13 +1146,13 @@ def rotate_api_key(
     )
 
 
-class BulkIngestItem(BaseModel):
+class BulkIngestItem(SynapseAPIModel):
     content: str = Field(..., min_length=1, max_length=32000)
     category: str = Field("interaction", min_length=1, max_length=64, pattern=r"^[a-z0-9_\-]+$")
     confidence: float = Field(0.95, ge=0.0, le=1.0)
 
 
-class BulkIngestRequest(BaseModel):
+class BulkIngestRequest(SynapseAPIModel):
     items: List[BulkIngestItem] = Field(..., min_length=1, max_length=100)
     tenant_id: Optional[str] = Field(None, alias="tenantId", min_length=1, max_length=128, pattern=r"^[A-Za-z0-9_\-\.]+$")
 

synapse_memory_engine-1.3.1/synapse_memory/client.py

@@ -0,0 +1,200 @@
+"""Canonical SynapseMemory Python client (Phase 6.1).
+
+Small, typed surface over the REST gateway — the supported path for
+external applications. Handles auth headers, timeouts, retries on
+retryable (429/5xx) failures, and the canonical {success, data} envelope.
+"""
+from __future__ import annotations
+
+import time
+from email.utils import parsedate_to_datetime
+from datetime import datetime, timezone
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+import requests
+
+__all__ = ["SynapseClient", "SynapseError", "CreateResult", "QueryResult"]
+
+SDK_VERSION = "1.3.1"
+API_COMPAT_VERSION = "v1"
+
+
+class SynapseError(Exception):
+    def __init__(self, message: str, *, status: Optional[int] = None, retryable: bool = False):
+        super().__init__(message)
+        self.status = status
+        self.retryable = retryable
+
+
+@dataclass
+class CreateResult:
+    id: str
+    status: str
+    token_cost: int
+    tenant_id: str
+
+
+@dataclass
+class QueryResult:
+    fused_context: str
+    injected_nodes_count: int
+    injected_nodes: List[Dict[str, Any]]
+    storage_backend: str
+
+
+class SynapseClient:
+    """Synchronous client; also usable as a context manager."""
+
+    def __init__(
+        self,
+        base_url: str = "http://127.0.0.1:8008",
+        api_key: Optional[str] = None,
+        tenant_id: str = "default",
+        timeout: float = 10.0,
+        max_retries: int = 3,
+    ):
+        if timeout <= 0:
+            raise ValueError("timeout must be greater than zero")
+        if max_retries < 0:
+            raise ValueError("max_retries must be zero or greater")
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.tenant_id = tenant_id
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self._session = requests.Session()
+
+    def __enter__(self) -> "SynapseClient":
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self._session.close()
+
+    def _headers(self) -> Dict[str, str]:
+        headers = {"Content-Type": "application/json", "X-Tenant-ID": self.tenant_id}
+        if self.api_key:
+            headers["X-Synapse-API-Key"] = self.api_key
+        return headers
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        payload: Optional[Dict[str, Any]] = None,
+        *,
+        retry_safe: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        """Perform a request without automatically replaying ambiguous writes.
+
+        GET/HEAD/OPTIONS are retry-safe by default. POST requests are not
+        retried unless the caller explicitly opts in with a proven idempotency
+        contract. This matters for /query too: retrieval updates access counts and
+        last-access timestamps. Mutation requests are not replayed after an
+        ambiguous timeout or 5xx response.
+        """
+        url = f"{self.base_url}{path}"
+        method = method.upper()
+        safe = method in {"GET", "HEAD", "OPTIONS"} if retry_safe is None else retry_safe
+        max_attempts = self.max_retries + 1 if safe else 1
+        last_error: Optional[SynapseError] = None
+
+        for attempt in range(max_attempts):
+            retry_after: Optional[float] = None
+            try:
+                resp = self._session.request(
+                    method, url, json=payload, headers=self._headers(), timeout=self.timeout
+                )
+            except requests.RequestException as exc:
+                if not safe:
+                    raise SynapseError(
+                        f"Connection failed during {method} {path}; the write outcome is unknown "
+                        "and was not automatically retried.",
+                        retryable=False,
+                    ) from exc
+                last_error = SynapseError(f"Connection failed: {exc}", retryable=True)
+            else:
+                if resp.status_code in (429, 502, 503, 504):
+                    if not safe:
+                        raise SynapseError(
+                            f"Transient HTTP {resp.status_code} for non-replay-safe {method} {path}; "
+                            "automatic retry suppressed to avoid duplicate mutations.",
+                            status=resp.status_code,
+                            retryable=True,
+                        )
+                    last_error = SynapseError(
+                        f"Retryable {resp.status_code}: {resp.text[:200]}",
+                        status=resp.status_code,
+                        retryable=True,
+                    )
+                    header = resp.headers.get("Retry-After")
+                    if header:
+                        try:
+                            retry_after = max(0.0, float(header))
+                        except ValueError:
+                            try:
+                                retry_after = max(
+                                    0.0,
+                                    (parsedate_to_datetime(header) - datetime.now(timezone.utc)).total_seconds(),
+                                )
+                            except (TypeError, ValueError, OverflowError):
+                                retry_after = None
+                elif not resp.ok:
+                    raise SynapseError(
+                        f"Request failed {resp.status_code}: {resp.text[:500]}",
+                        status=resp.status_code,
+                    )
+                else:
+                    try:
+                        body = resp.json()
+                    except ValueError as exc:
+                        raise SynapseError(
+                            f"API returned invalid JSON for {method} {path}",
+                            status=resp.status_code,
+                        ) from exc
+                    if isinstance(body, dict) and "success" in body and "data" in body:
+                        if not body["success"]:
+                            raise SynapseError(
+                                f"API error: {body.get('error')}", status=resp.status_code
+                            )
+                        return body["data"]
+                    return body
+
+            if attempt < max_attempts - 1:
+                backoff = min(2.0, 0.25 * (2 ** attempt))
+                time.sleep(retry_after if retry_after is not None else backoff)
+
+        raise last_error or SynapseError("Request failed")
+
+    def create_memory(self, content: str, category: str = "interaction", confidence: float = 0.95) -> CreateResult:
+        data = self._request("POST", "/ingest", {"content": content, "category": category, "confidence": confidence})
+        return CreateResult(id=data["id"], status=data["status"], token_cost=data["token_cost"], tenant_id=data["tenant_id"])
+
+    def retrieve(self, query: str, max_tokens: int = 1500) -> QueryResult:
+        data = self._request(
+            "POST", "/query", {"prompt": query, "maxTokens": max_tokens}
+        )
+        return QueryResult(
+            fused_context=data.get("fused_context", ""),
+            injected_nodes_count=data.get("injected_nodes_count", 0),
+            injected_nodes=data.get("injected_nodes", []),
+            storage_backend=data.get("active_storage_backend", "unknown"),
+        )
+
+    def list_memories(self, limit: int = 50, offset: int = 0) -> Dict[str, Any]:
+        return self._request("GET", f"/api/memories/list?limit={limit}&offset={offset}")
+
+    def delete_memory(self, memory_id: str) -> Dict[str, Any]:
+        return self._request("DELETE", f"/api/memories/{memory_id}")
+
+    def feedback(self, memory_id: str, feedback_type: str) -> Dict[str, Any]:
+        return self._request("POST", "/feedback", {"memory_id": memory_id, "feedback_type": feedback_type})
+
+    def health(self) -> Dict[str, Any]:
+        return self._request("GET", "/health")
+
+    def readiness(self) -> Dict[str, Any]:
+        return self._request("GET", "/readiness")

{synapse_memory_engine-1.3.0 → synapse_memory_engine-1.3.1}/synapse_memory/core/embedder.py

@@ -66,7 +66,8 @@ class SynapseEmbedder:
                     "(gemini, openai, sentence-transformers) or opt in with "
                     "SYNAPSE_ALLOW_DETERMINISTIC_EMBEDDING=true."
                 )
-            dim = int(os.getenv("SYNAPSE_EMBEDDING_DIMENSION", "128"))
+            raw_dimension = os.getenv("SYNAPSE_EMBEDDING_DIMENSION", "").strip()
+            dim = int(raw_dimension) if raw_dimension else 128
             return LocalEmbeddingProvider(dim=dim)
         elif self.provider_name == "gemini":
             if not self.gemini_key:
@@ -74,26 +75,32 @@ class SynapseEmbedder:
                     logger.warning(
                         "GEMINI_API_KEY not set; falling back to deterministic hash provider."
                     )
-                    dim = int(os.getenv("SYNAPSE_EMBEDDING_DIMENSION", "128"))
+                    raw_dimension = os.getenv("SYNAPSE_EMBEDDING_DIMENSION", "").strip()
+                    dim = int(raw_dimension) if raw_dimension else 128
                     return LocalEmbeddingProvider(dim=dim)
                 raise RuntimeError(
                     "SYNAPSE_EMBEDDING_PROVIDER=gemini but GEMINI_API_KEY is not set. "
                     "Set GEMINI_API_KEY or switch to provider=deterministic."
                 )
-            return GeminiEmbeddingProvider(self.gemini_key)
+            raw_dimension = os.getenv("SYNAPSE_EMBEDDING_DIMENSION", "").strip()
+            dimension = int(raw_dimension) if raw_dimension else 3072
+            return GeminiEmbeddingProvider(self.gemini_key, dim=dimension)
         elif self.provider_name == "openai":
             if not self.openai_key:
                 if allow_fallback:
                     logger.warning(
                         "OPENAI_API_KEY not set; falling back to deterministic hash provider."
                     )
-                    dim = int(os.getenv("SYNAPSE_EMBEDDING_DIMENSION", "128"))
+                    raw_dimension = os.getenv("SYNAPSE_EMBEDDING_DIMENSION", "").strip()
+                    dim = int(raw_dimension) if raw_dimension else 128
                     return LocalEmbeddingProvider(dim=dim)
                 raise RuntimeError(
                     "SYNAPSE_EMBEDDING_PROVIDER=openai but OPENAI_API_KEY is not set. "
                     "Set OPENAI_API_KEY or switch to provider=deterministic."
                 )
-            return OpenAIEmbeddingProvider(self.openai_key)
+            raw_dimension = os.getenv("SYNAPSE_EMBEDDING_DIMENSION", "").strip()
+            dimension = int(raw_dimension) if raw_dimension else 1536
+            return OpenAIEmbeddingProvider(self.openai_key, dim=dimension)
         elif self.provider_name == "sentence-transformers":
             # Explicit opt-in: requires [local-models] extra and model availability.
             return SentenceTransformerEmbeddingProvider(
@@ -105,7 +112,8 @@ class SynapseEmbedder:
             logger.warning(
                 f"Unknown embedding provider '{self.provider_name}'; falling back to deterministic hash provider."
             )
-            dim = int(os.getenv("SYNAPSE_EMBEDDING_DIMENSION", "128"))
+            raw_dimension = os.getenv("SYNAPSE_EMBEDDING_DIMENSION", "").strip()
+            dim = int(raw_dimension) if raw_dimension else 128
             return LocalEmbeddingProvider(dim=dim)
         raise RuntimeError(
             f"Unknown embedding provider '{self.provider_name}'. "

{synapse_memory_engine-1.3.0 → synapse_memory_engine-1.3.1}/synapse_memory/core/embedding_provider.py

@@ -171,7 +171,11 @@ class GeminiEmbeddingProvider(EmbeddingProvider):
             f"gemini-embedding-001:embedContent?key={self.api_key}"
         )
         headers = {"Content-Type": "application/json"}
-        payload = {"content": {"parts": [{"text": text}]}}
+        payload = {
+            "content": {"parts": [{"text": text}]},
+            # Prefer EmbedContentConfig over the deprecated top-level field.
+            "embedContentConfig": {"outputDimensionality": self._dim},
+        }
 
         req = urllib.request.Request(
             url,
@@ -208,10 +212,14 @@ class OpenAIEmbeddingProvider(EmbeddingProvider):
             "Content-Type": "application/json",
             "Authorization": f"Bearer {self.api_key}"
         }
-        payload = {
+        payload: dict[str, object] = {
             "input": text,
             "model": self.model
         }
+        # text-embedding-3 models support an explicit output width. Older model
+        # families do not accept the dimensions field and keep their native size.
+        if self.model.startswith("text-embedding-3"):
+            payload["dimensions"] = self._dim
         req = urllib.request.Request(
             url,
             data=json.dumps(payload).encode("utf-8"),