agentrun-mem0ai 0.0.11__py3-none-any.whl

agentrun_mem0/configs/vector_stores/opensearch.py

@@ -0,0 +1,41 @@
+from typing import Any, Dict, Optional, Type, Union
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class OpenSearchConfig(BaseModel):
+    collection_name: str = Field("mem0", description="Name of the index")
+    host: str = Field("localhost", description="OpenSearch host")
+    port: int = Field(9200, description="OpenSearch port")
+    user: Optional[str] = Field(None, description="Username for authentication")
+    password: Optional[str] = Field(None, description="Password for authentication")
+    api_key: Optional[str] = Field(None, description="API key for authentication (if applicable)")
+    embedding_model_dims: int = Field(1536, description="Dimension of the embedding vector")
+    verify_certs: bool = Field(False, description="Verify SSL certificates (default False for OpenSearch)")
+    use_ssl: bool = Field(False, description="Use SSL for connection (default False for OpenSearch)")
+    http_auth: Optional[object] = Field(None, description="HTTP authentication method / AWS SigV4")
+    connection_class: Optional[Union[str, Type]] = Field(
+        "RequestsHttpConnection", description="Connection class for OpenSearch"
+    )
+    pool_maxsize: int = Field(20, description="Maximum number of connections in the pool")
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_auth(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        # Check if host is provided
+        if not values.get("host"):
+            raise ValueError("Host must be provided for OpenSearch")
+
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Allowed fields: {', '.join(allowed_fields)}"
+            )
+        return values

agentrun_mem0/configs/vector_stores/pgvector.py

@@ -0,0 +1,52 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class PGVectorConfig(BaseModel):
+    dbname: str = Field("postgres", description="Default name for the database")
+    collection_name: str = Field("mem0", description="Default name for the collection")
+    embedding_model_dims: Optional[int] = Field(1536, description="Dimensions of the embedding model")
+    user: Optional[str] = Field(None, description="Database user")
+    password: Optional[str] = Field(None, description="Database password")
+    host: Optional[str] = Field(None, description="Database host. Default is localhost")
+    port: Optional[int] = Field(None, description="Database port. Default is 1536")
+    diskann: Optional[bool] = Field(False, description="Use diskann for approximate nearest neighbors search")
+    hnsw: Optional[bool] = Field(True, description="Use hnsw for faster search")
+    minconn: Optional[int] = Field(1, description="Minimum number of connections in the pool")
+    maxconn: Optional[int] = Field(5, description="Maximum number of connections in the pool")
+    # New SSL and connection options
+    sslmode: Optional[str] = Field(None, description="SSL mode for PostgreSQL connection (e.g., 'require', 'prefer', 'disable')")
+    connection_string: Optional[str] = Field(None, description="PostgreSQL connection string (overrides individual connection parameters)")
+    connection_pool: Optional[Any] = Field(None, description="psycopg connection pool object (overrides connection string and individual parameters)")
+
+    @model_validator(mode="before")
+    def check_auth_and_connection(cls, values):
+        # If connection_pool is provided, skip validation of individual connection parameters
+        if values.get("connection_pool") is not None:
+            return values
+
+        # If connection_string is provided, skip validation of individual connection parameters
+        if values.get("connection_string") is not None:
+            return values
+        
+        # Otherwise, validate individual connection parameters
+        user, password = values.get("user"), values.get("password")
+        host, port = values.get("host"), values.get("port")
+        if not user and not password:
+            raise ValueError("Both 'user' and 'password' must be provided when not using connection_string.")
+        if not host and not port:
+            raise ValueError("Both 'host' and 'port' must be provided when not using connection_string.")
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
+            )
+        return values

agentrun_mem0/configs/vector_stores/pinecone.py

@@ -0,0 +1,55 @@
+import os
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class PineconeConfig(BaseModel):
+    """Configuration for Pinecone vector database."""
+
+    collection_name: str = Field("mem0", description="Name of the index/collection")
+    embedding_model_dims: int = Field(1536, description="Dimensions of the embedding model")
+    client: Optional[Any] = Field(None, description="Existing Pinecone client instance")
+    api_key: Optional[str] = Field(None, description="API key for Pinecone")
+    environment: Optional[str] = Field(None, description="Pinecone environment")
+    serverless_config: Optional[Dict[str, Any]] = Field(None, description="Configuration for serverless deployment")
+    pod_config: Optional[Dict[str, Any]] = Field(None, description="Configuration for pod-based deployment")
+    hybrid_search: bool = Field(False, description="Whether to enable hybrid search")
+    metric: str = Field("cosine", description="Distance metric for vector similarity")
+    batch_size: int = Field(100, description="Batch size for operations")
+    extra_params: Optional[Dict[str, Any]] = Field(None, description="Additional parameters for Pinecone client")
+    namespace: Optional[str] = Field(None, description="Namespace for the collection")
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_api_key_or_client(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        api_key, client = values.get("api_key"), values.get("client")
+        if not api_key and not client and "PINECONE_API_KEY" not in os.environ:
+            raise ValueError(
+                "Either 'api_key' or 'client' must be provided, or PINECONE_API_KEY environment variable must be set."
+            )
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_pod_or_serverless(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        pod_config, serverless_config = values.get("pod_config"), values.get("serverless_config")
+        if pod_config and serverless_config:
+            raise ValueError(
+                "Both 'pod_config' and 'serverless_config' cannot be specified. Choose one deployment option."
+            )
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
+            )
+        return values
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)

agentrun_mem0/configs/vector_stores/qdrant.py

@@ -0,0 +1,47 @@
+from typing import Any, ClassVar, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class QdrantConfig(BaseModel):
+    from qdrant_client import QdrantClient
+
+    QdrantClient: ClassVar[type] = QdrantClient
+
+    collection_name: str = Field("mem0", description="Name of the collection")
+    embedding_model_dims: Optional[int] = Field(1536, description="Dimensions of the embedding model")
+    client: Optional[QdrantClient] = Field(None, description="Existing Qdrant client instance")
+    host: Optional[str] = Field(None, description="Host address for Qdrant server")
+    port: Optional[int] = Field(None, description="Port for Qdrant server")
+    path: Optional[str] = Field("/tmp/qdrant", description="Path for local Qdrant database")
+    url: Optional[str] = Field(None, description="Full URL for Qdrant server")
+    api_key: Optional[str] = Field(None, description="API key for Qdrant server")
+    on_disk: Optional[bool] = Field(False, description="Enables persistent storage")
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_host_port_or_path(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        host, port, path, url, api_key = (
+            values.get("host"),
+            values.get("port"),
+            values.get("path"),
+            values.get("url"),
+            values.get("api_key"),
+        )
+        if not path and not (host and port) and not (url and api_key):
+            raise ValueError("Either 'host' and 'port' or 'url' and 'api_key' or 'path' must be provided.")
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
+            )
+        return values
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)

agentrun_mem0/configs/vector_stores/redis.py

@@ -0,0 +1,24 @@
+from typing import Any, Dict
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+# TODO: Upgrade to latest pydantic version
+class RedisDBConfig(BaseModel):
+    redis_url: str = Field(..., description="Redis URL")
+    collection_name: str = Field("mem0", description="Collection name")
+    embedding_model_dims: int = Field(1536, description="Embedding model dimensions")
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
+            )
+        return values
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)

agentrun_mem0/configs/vector_stores/s3_vectors.py

@@ -0,0 +1,28 @@
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class S3VectorsConfig(BaseModel):
+    vector_bucket_name: str = Field(description="Name of the S3 Vector bucket")
+    collection_name: str = Field("mem0", description="Name of the vector index")
+    embedding_model_dims: int = Field(1536, description="Dimension of the embedding vector")
+    distance_metric: str = Field(
+        "cosine",
+        description="Distance metric for similarity search. Options: 'cosine', 'euclidean'",
+    )
+    region_name: Optional[str] = Field(None, description="AWS region for the S3 Vectors client")
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
+            )
+        return values
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)

agentrun_mem0/configs/vector_stores/supabase.py

@@ -0,0 +1,44 @@
+from enum import Enum
+from typing import Any, Dict, Optional
+
+from pydantic import BaseModel, Field, model_validator
+
+
+class IndexMethod(str, Enum):
+    AUTO = "auto"
+    HNSW = "hnsw"
+    IVFFLAT = "ivfflat"
+
+
+class IndexMeasure(str, Enum):
+    COSINE = "cosine_distance"
+    L2 = "l2_distance"
+    L1 = "l1_distance"
+    MAX_INNER_PRODUCT = "max_inner_product"
+
+
+class SupabaseConfig(BaseModel):
+    connection_string: str = Field(..., description="PostgreSQL connection string")
+    collection_name: str = Field("mem0", description="Name for the vector collection")
+    embedding_model_dims: Optional[int] = Field(1536, description="Dimensions of the embedding model")
+    index_method: Optional[IndexMethod] = Field(IndexMethod.AUTO, description="Index method to use")
+    index_measure: Optional[IndexMeasure] = Field(IndexMeasure.COSINE, description="Distance measure to use")
+
+    @model_validator(mode="before")
+    def check_connection_string(cls, values):
+        conn_str = values.get("connection_string")
+        if not conn_str or not conn_str.startswith("postgresql://"):
+            raise ValueError("A valid PostgreSQL connection string must be provided")
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
+            )
+        return values

agentrun_mem0/configs/vector_stores/upstash_vector.py

@@ -0,0 +1,34 @@
+import os
+from typing import Any, ClassVar, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+try:
+    from upstash_vector import Index
+except ImportError:
+    raise ImportError("The 'upstash_vector' library is required. Please install it using 'pip install upstash_vector'.")
+
+
+class UpstashVectorConfig(BaseModel):
+    Index: ClassVar[type] = Index
+
+    url: Optional[str] = Field(None, description="URL for Upstash Vector index")
+    token: Optional[str] = Field(None, description="Token for Upstash Vector index")
+    client: Optional[Index] = Field(None, description="Existing `upstash_vector.Index` client instance")
+    collection_name: str = Field("mem0", description="Namespace to use for the index")
+    enable_embeddings: bool = Field(
+        False, description="Whether to use built-in upstash embeddings or not. Default is True."
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_credentials_or_client(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        client = values.get("client")
+        url = values.get("url") or os.environ.get("UPSTASH_VECTOR_REST_URL")
+        token = values.get("token") or os.environ.get("UPSTASH_VECTOR_REST_TOKEN")
+
+        if not client and not (url and token):
+            raise ValueError("Either a client or URL and token must be provided.")
+        return values
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)

agentrun_mem0/configs/vector_stores/valkey.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+
+
+class ValkeyConfig(BaseModel):
+    """Configuration for Valkey vector store."""
+
+    valkey_url: str
+    collection_name: str
+    embedding_model_dims: int
+    timezone: str = "UTC"
+    index_type: str = "hnsw"  # Default to HNSW, can be 'hnsw' or 'flat'
+    # HNSW specific parameters with recommended defaults
+    hnsw_m: int = 16  # Number of connections per layer (default from Valkey docs)
+    hnsw_ef_construction: int = 200  # Search width during construction
+    hnsw_ef_runtime: int = 10  # Search width during queries

agentrun_mem0/configs/vector_stores/vertex_ai_vector_search.py

@@ -0,0 +1,28 @@
+from typing import Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class GoogleMatchingEngineConfig(BaseModel):
+    project_id: str = Field(description="Google Cloud project ID")
+    project_number: str = Field(description="Google Cloud project number")
+    region: str = Field(description="Google Cloud region")
+    endpoint_id: str = Field(description="Vertex AI Vector Search endpoint ID")
+    index_id: str = Field(description="Vertex AI Vector Search index ID")
+    deployment_index_id: str = Field(description="Deployment-specific index ID")
+    collection_name: Optional[str] = Field(None, description="Collection name, defaults to index_id")
+    credentials_path: Optional[str] = Field(None, description="Path to service account credentials JSON file")
+    service_account_json: Optional[Dict] = Field(None, description="Service account credentials as dictionary (alternative to credentials_path)")
+    vector_search_api_endpoint: Optional[str] = Field(None, description="Vector search API endpoint")
+
+    model_config = ConfigDict(extra="forbid")
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        if not self.collection_name:
+            self.collection_name = self.index_id
+
+    def model_post_init(self, _context) -> None:
+        """Set collection_name to index_id if not provided"""
+        if self.collection_name is None:
+            self.collection_name = self.index_id

agentrun_mem0/configs/vector_stores/weaviate.py

@@ -0,0 +1,41 @@
+from typing import Any, ClassVar, Dict, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class WeaviateConfig(BaseModel):
+    from weaviate import WeaviateClient
+
+    WeaviateClient: ClassVar[type] = WeaviateClient
+
+    collection_name: str = Field("mem0", description="Name of the collection")
+    embedding_model_dims: int = Field(1536, description="Dimensions of the embedding model")
+    cluster_url: Optional[str] = Field(None, description="URL for Weaviate server")
+    auth_client_secret: Optional[str] = Field(None, description="API key for Weaviate authentication")
+    additional_headers: Optional[Dict[str, str]] = Field(None, description="Additional headers for requests")
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_connection_params(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        cluster_url = values.get("cluster_url")
+
+        if not cluster_url:
+            raise ValueError("'cluster_url' must be provided.")
+
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_extra_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        allowed_fields = set(cls.model_fields.keys())
+        input_fields = set(values.keys())
+        extra_fields = input_fields - allowed_fields
+
+        if extra_fields:
+            raise ValueError(
+                f"Extra fields not allowed: {', '.join(extra_fields)}. Please input only the following fields: {', '.join(allowed_fields)}"
+            )
+
+        return values
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)

agentrun_mem0/embeddings/aws_bedrock.py

@@ -0,0 +1,100 @@
+import json
+import os
+from typing import Literal, Optional
+
+try:
+    import boto3
+except ImportError:
+    raise ImportError("The 'boto3' library is required. Please install it using 'pip install boto3'.")
+
+import numpy as np
+
+from agentrun_mem0.configs.embeddings.base import BaseEmbedderConfig
+from agentrun_mem0.embeddings.base import EmbeddingBase
+
+
+class AWSBedrockEmbedding(EmbeddingBase):
+    """AWS Bedrock embedding implementation.
+
+    This class uses AWS Bedrock's embedding models.
+    """
+
+    def __init__(self, config: Optional[BaseEmbedderConfig] = None):
+        super().__init__(config)
+
+        self.config.model = self.config.model or "amazon.titan-embed-text-v1"
+
+        # Get AWS config from environment variables or use defaults
+        aws_access_key = os.environ.get("AWS_ACCESS_KEY_ID", "")
+        aws_secret_key = os.environ.get("AWS_SECRET_ACCESS_KEY", "")
+        aws_session_token = os.environ.get("AWS_SESSION_TOKEN", "")
+
+        # Check if AWS config is provided in the config
+        if hasattr(self.config, "aws_access_key_id"):
+            aws_access_key = self.config.aws_access_key_id
+        if hasattr(self.config, "aws_secret_access_key"):
+            aws_secret_key = self.config.aws_secret_access_key
+        
+        # AWS region is always set in config - see BaseEmbedderConfig
+        aws_region = self.config.aws_region or "us-west-2"
+
+        self.client = boto3.client(
+            "bedrock-runtime",
+            region_name=aws_region,
+            aws_access_key_id=aws_access_key if aws_access_key else None,
+            aws_secret_access_key=aws_secret_key if aws_secret_key else None,
+            aws_session_token=aws_session_token if aws_session_token else None,
+        )
+
+    def _normalize_vector(self, embeddings):
+        """Normalize the embedding to a unit vector."""
+        emb = np.array(embeddings)
+        norm_emb = emb / np.linalg.norm(emb)
+        return norm_emb.tolist()
+
+    def _get_embedding(self, text):
+        """Call out to Bedrock embedding endpoint."""
+
+        # Format input body based on the provider
+        provider = self.config.model.split(".")[0]
+        input_body = {}
+
+        if provider == "cohere":
+            input_body["input_type"] = "search_document"
+            input_body["texts"] = [text]
+        else:
+            # Amazon and other providers
+            input_body["inputText"] = text
+
+        body = json.dumps(input_body)
+
+        try:
+            response = self.client.invoke_model(
+                body=body,
+                modelId=self.config.model,
+                accept="application/json",
+                contentType="application/json",
+            )
+
+            response_body = json.loads(response.get("body").read())
+
+            if provider == "cohere":
+                embeddings = response_body.get("embeddings")[0]
+            else:
+                embeddings = response_body.get("embedding")
+
+            return embeddings
+        except Exception as e:
+            raise ValueError(f"Error getting embedding from AWS Bedrock: {e}")
+
+    def embed(self, text, memory_action: Optional[Literal["add", "search", "update"]] = None):
+        """
+        Get the embedding for the given text using AWS Bedrock.
+
+        Args:
+            text (str): The text to embed.
+            memory_action (optional): The type of embedding to use. Must be one of "add", "search", or "update". Defaults to None.
+        Returns:
+            list: The embedding vector.
+        """
+        return self._get_embedding(text)

agentrun_mem0/embeddings/azure_openai.py

@@ -0,0 +1,55 @@
+import os
+from typing import Literal, Optional
+
+from azure.identity import DefaultAzureCredential, get_bearer_token_provider
+from openai import AzureOpenAI
+
+from agentrun_mem0.configs.embeddings.base import BaseEmbedderConfig
+from agentrun_mem0.embeddings.base import EmbeddingBase
+
+SCOPE = "https://cognitiveservices.azure.com/.default"
+
+
+class AzureOpenAIEmbedding(EmbeddingBase):
+    def __init__(self, config: Optional[BaseEmbedderConfig] = None):
+        super().__init__(config)
+
+        api_key = self.config.azure_kwargs.api_key or os.getenv("EMBEDDING_AZURE_OPENAI_API_KEY")
+        azure_deployment = self.config.azure_kwargs.azure_deployment or os.getenv("EMBEDDING_AZURE_DEPLOYMENT")
+        azure_endpoint = self.config.azure_kwargs.azure_endpoint or os.getenv("EMBEDDING_AZURE_ENDPOINT")
+        api_version = self.config.azure_kwargs.api_version or os.getenv("EMBEDDING_AZURE_API_VERSION")
+        default_headers = self.config.azure_kwargs.default_headers
+
+        # If the API key is not provided or is a placeholder, use DefaultAzureCredential.
+        if api_key is None or api_key == "" or api_key == "your-api-key":
+            self.credential = DefaultAzureCredential()
+            azure_ad_token_provider = get_bearer_token_provider(
+                self.credential,
+                SCOPE,
+            )
+            api_key = None
+        else:
+            azure_ad_token_provider = None
+
+        self.client = AzureOpenAI(
+            azure_deployment=azure_deployment,
+            azure_endpoint=azure_endpoint,
+            azure_ad_token_provider=azure_ad_token_provider,
+            api_version=api_version,
+            api_key=api_key,
+            http_client=self.config.http_client,
+            default_headers=default_headers,
+        )
+
+    def embed(self, text, memory_action: Optional[Literal["add", "search", "update"]] = None):
+        """
+        Get the embedding for the given text using OpenAI.
+
+        Args:
+            text (str): The text to embed.
+            memory_action (optional): The type of embedding to use. Must be one of "add", "search", or "update". Defaults to None.
+        Returns:
+            list: The embedding vector.
+        """
+        text = text.replace("\n", " ")
+        return self.client.embeddings.create(input=[text], model=self.config.model).data[0].embedding

agentrun_mem0/embeddings/base.py

@@ -0,0 +1,31 @@
+from abc import ABC, abstractmethod
+from typing import Literal, Optional
+
+from agentrun_mem0.configs.embeddings.base import BaseEmbedderConfig
+
+
+class EmbeddingBase(ABC):
+    """Initialized a base embedding class
+
+    :param config: Embedding configuration option class, defaults to None
+    :type config: Optional[BaseEmbedderConfig], optional
+    """
+
+    def __init__(self, config: Optional[BaseEmbedderConfig] = None):
+        if config is None:
+            self.config = BaseEmbedderConfig()
+        else:
+            self.config = config
+
+    @abstractmethod
+    def embed(self, text, memory_action: Optional[Literal["add", "search", "update"]]):
+        """
+        Get the embedding for the given text.
+
+        Args:
+            text (str): The text to embed.
+            memory_action (optional): The type of embedding to use. Must be one of "add", "search", or "update". Defaults to None.
+        Returns:
+            list: The embedding vector.
+        """
+        pass

agentrun_mem0/embeddings/configs.py

@@ -0,0 +1,30 @@
+from typing import Optional
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class EmbedderConfig(BaseModel):
+    provider: str = Field(
+        description="Provider of the embedding model (e.g., 'ollama', 'openai')",
+        default="openai",
+    )
+    config: Optional[dict] = Field(description="Configuration for the specific embedding model", default={})
+
+    @field_validator("config")
+    def validate_config(cls, v, values):
+        provider = values.data.get("provider")
+        if provider in [
+            "openai",
+            "ollama",
+            "huggingface",
+            "azure_openai",
+            "gemini",
+            "vertexai",
+            "together",
+            "lmstudio",
+            "langchain",
+            "aws_bedrock",
+        ]:
+            return v
+        else:
+            raise ValueError(f"Unsupported embedding provider: {provider}")