swarmauri_vectorstore_redis 0.6.0.dev154__py3-none-any.whl → 0.7.0.dev3__py3-none-any.whl

swarmauri_vectorstore_redis/RedisDocumentRetriever.py

@@ -1,59 +1,57 @@
-from typing import List
-from redisearch import Client, Query
-from swarmauri_core.documents.IDocument import IDocument
-from swarmauri_standard.document_stores.ConcreteDocument import (
-    ConcreteDocument,
-)
-from swarmauri_base.retrievers.DocumentRetrieverBase import DocumentRetrieverBase
-from swarmauri_core.ComponentBase import ComponentBase
-
-@ComponentBase.register_type(DocumentRetrieverBase, "RedisDocumentRetriever")
-class RedisDocumentRetriever(DocumentRetrieverBase):
-    """
-    A document retriever that fetches documents from a Redis store.
-    """
-
-    def __init__(self, redis_idx_name, redis_host, redis_port):
-        """
-        Initializes a new instance of RedisDocumentRetriever.
-
-        Args:
-            redis_client (Redis): An instance of the Redis client.
-        """
-        self._redis_client = None
-        self._redis_idx_name = redis_idx_name
-        self._redis_host = redis_host
-        self._redis_port = redis_port
-
-    @property
-    def redis_client(self):
-        """Lazily initialize and return the Redis client using a factory method."""
-        if self._redis_client is None:
-            self._redis_client = Client(
-                self.redis_idx_name, host=self.redis_host, port=self.redis_port
-            )
-        return self._redis_client
-
-    def retrieve(self, query: str, top_k: int = 5) -> List[IDocument]:
-        """
-        Retrieve the most relevant documents based on the given query.
-
-        Args:
-            query (str): The query string used for document retrieval.
-            top_k (int, optional): The number of top relevant documents to retrieve. Defaults to 5.
-
-        Returns:
-            List[IDocument]: A list of the top_k most relevant documents.
-        """
-        query_result = self.redis_client.search(Query(query).paging(0, top_k))
-
-        documents = [
-            ConcreteDocument(
-                doc_id=doc.id,
-                content=doc.text,  # Note: Adjust 'text' based on actual Redis document schema
-                metadata=doc.__dict__,  # Including full document fields and values in metadata
-            )
-            for doc in query_result.docs
-        ]
-
-        return documents
+from typing import List, Optional
+
+from pydantic import Field, PrivateAttr
+from redisearch import Client, Query
+from swarmauri_base.document_stores.DocumentStoreRetrieveBase import (
+    DocumentStoreRetrieveBase,
+)
+from swarmauri_base.ComponentBase import ComponentBase
+from swarmauri_standard.documents.Document import Document
+
+
+@ComponentBase.register_type(DocumentStoreRetrieveBase, "RedisDocumentRetriever")
+class RedisDocumentRetriever(DocumentStoreRetrieveBase):
+    """
+    A document retriever that fetches documents from a Redis store.
+    """
+
+    type: str = "RedisDocumentRetriever"
+    redis_idx_name: str = Field(..., description="Redis index name")
+    redis_host: str = Field(default="localhost", description="Redis host")
+    redis_port: int = Field(default=6379, description="Redis port")
+
+    # Private attributes
+    _redis_client: Optional[Client] = PrivateAttr(default=None)
+
+    @property
+    def redis_client(self) -> Client:
+        """Lazily initialize and return the Redis client using a factory method."""
+        if self._redis_client is None:
+            self._redis_client = Client(
+                self.redis_idx_name, host=self.redis_host, port=self.redis_port
+            )
+        return self._redis_client
+
+    def retrieve(self, query: str, top_k: int = 5) -> List[Document]:
+        """
+        Retrieve the most relevant documents based on the given query.
+
+        Args:
+            query (str): The query string used for document retrieval.
+            top_k (int, optional): The number of top relevant documents to retrieve. Defaults to 5.
+
+        Returns:
+            List[Document]: A list of the top_k most relevant documents.
+        """
+        query_result = self.redis_client.search(Query(query).paging(0, top_k))
+
+        documents = [
+            Document(
+                id=doc.id,
+                content=doc.content,  # Note: Adjust 'text' based on actual Redis document schema
+                metadata=doc.__dict__,  # Including full document fields and values in metadata
+            )
+            for doc in query_result.docs
+        ]
+
+        return documents

swarmauri_vectorstore_redis/RedisVectorStore.py

@@ -1,238 +1,236 @@
-import json
-from typing import List, Union, Literal, Optional
-from pydantic import PrivateAttr
-
-import numpy as np
-import redis
-from redis.commands.search.field import VectorField, TextField
-from redis.commands.search.indexDefinition import IndexDefinition, IndexType
-
-from swarmauri_standard.vectors.Vector import Vector
-from swarmauri_standard.documents.concrete.Document import Document
-from swarmauri_embedding_doc2vec.Doc2VecEmbedding import Doc2VecEmbedding
-from swarmauri_base.vector_stores.VectorStoreBase import VectorStoreBase
-from swarmauri_base.vector_stores.VectorStoreRetrieveMixin import VectorStoreRetrieveMixin
-from swarmauri_base.vector_stores.VectorStoreSaveLoadMixin import VectorStoreSaveLoadMixin
-from swarmauri_core.ComponentBase import ComponentBase
-
-@ComponentBase.register_type(VectorStoreBase, "RedisVectorStore")
-class RedisVectorStore(VectorStoreSaveLoadMixin, VectorStoreRetrieveMixin, VectorStoreBase):
-    type: Literal["RedisVectorStore"] = "RedisVectorStore"
-    index_name: str = "documents_index"
-    embedding_dimension: int = 8000  # Default embedding dimension
-
-    # Private attributes
-    _embedder: Doc2VecEmbedding = PrivateAttr()
-    _redis_client: Optional[redis.Redis] = PrivateAttr(default=None)
-
-    # Configuration attributes with default values
-    redis_host: str = "localhost"
-    redis_port: int = 6379
-    redis_password: Optional[str] = None
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self._embedder = Doc2VecEmbedding(vector_size=self.embedding_dimension)
-
-        # Initialize Redis client using class attributes
-        self.connect()
-
-        # Setup Redis Search index
-        vector_field = VectorField(
-            "embedding",
-            "FLAT",
-            {
-                "TYPE": "FLOAT32",
-                "DIM": self.embedding_dimension,
-                "DISTANCE_METRIC": "COSINE"
-            }
-        )
-        text_field = TextField("content")
-
-        try:
-            self._redis_client.ft(self.index_name).info()
-            print(f"Index '{self.index_name}' exists.")
-        except Exception:
-            print(f"Index '{self.index_name}' does not exist. Creating index...")
-            schema = (
-                text_field,
-                vector_field
-            )
-            definition = IndexDefinition(
-                prefix=["doc:"],
-                index_type=IndexType.HASH
-            )
-            self._redis_client.ft(self.index_name).create_index(
-                fields=schema,
-                definition=definition
-            )
-            print(f"Index '{self.index_name}' created successfully.")
-
-
-    def connect(self) -> None:
-        """
-        Establishes a connection to the Redis server using class attributes.
-        """
-        try:
-            self._redis_client = redis.Redis(
-                host=self.redis_host,
-                port=self.redis_port,
-                password=self.redis_password,
-                decode_responses=False,  # For binary data
-            )
-            # Test the connection
-            self._redis_client.ping()
-            print("Connected to Redis successfully.")
-        except Exception as e:
-            print(f"Failed to connect to Redis: {e}")
-            raise
-
-    def disconnect(self) -> None:
-        """
-        Disconnects from the Redis server.
-        """
-        if self._redis_client:
-            self._redis_client.close()
-            self._redis_client = None
-            print("Disconnected from Redis.")
-       
-
-    def _doc_key(self, document_id: str) -> str:
-        return f"doc:{document_id}"
-
-    def add_document(self, document: Document) -> None:
-        doc = document
-        pipeline = self._redis_client.pipeline()
-    
-            # Embed the document content
-        embedding = self._embedder.fit_transform([doc.content])[0]
-
-        if isinstance(embedding, Vector):
-            embedding = embedding.value 
-        metadata = doc.metadata
-               
-        # print("METADATA ::::::::::::::::::::", metadata)
-        doc_key = self._doc_key(doc.id)
-        # print("DOC KEY ::::::::::::::::::::", doc_key)
-        pipeline.hset(doc_key, mapping={
-            "content": doc.content,
-            "metadata": json.dumps(metadata),  # Store metadata as JSON
-            "embedding": np.array(embedding, dtype=np.float32).tobytes()  # Convert embedding values to bytes
-        })
-        add = pipeline.execute()
-
-    def add_documents(self, documents: List[Document]) -> None:
-        pipeline = self._redis_client.pipeline()
-        for doc in documents:
-            if not doc.content:
-                continue
-            # Embed the document content
-            embedding = self._embedder.fit_transform([doc.content])[0]
-            
-            if isinstance(embedding, Vector):
-                embedding = embedding.value
-            metadata={doc.metadata}
-           
-            doc_key = self._doc_key(doc.id)
-            pipeline.hset(doc_key, mapping={
-                "content": doc.content,
-                "metadata": json.dumps(metadata),
-                "embedding": np.array(embedding, dtype=np.float32).tobytes()
-            })
-        pipeline.execute()
-
-    def get_document(self, id: str) -> Union[Document, None]:
-        
-        doc_key = self._doc_key(id)
-        data = self._redis_client.hgetall(doc_key)
-        if not data:
-            return None
-        
-        metadata_raw = data.get(b"metadata", b"{}").decode("utf-8")  
-        metadata = json.loads(metadata_raw)
-
-        content = data.get(b"content", b"").decode("utf-8")
-        # print("METAAAAAAA ::::::::::::", metadata)
-
-        embedding_bytes = data.get(b"embedding")
-        if embedding_bytes:
-            embedding = Vector(value=np.frombuffer(embedding_bytes, dtype=np.float32).tolist())
-        else:
-            embedding = None
-        return Document(
-            id=id,
-            content=content,
-            metadata=metadata,
-            embedding=embedding
-        )
-
-    def get_all_documents(self) -> List[Document]:
-        cursor = '0'
-        documents = []
-        while cursor != 0:
-            cursor, keys = self._redis_client.scan(cursor=cursor, match="doc:*", count=1000)
-            for key in keys:
-                data = self._redis_client.hgetall(key)
-                if not data:
-                    continue
-                doc_id = key.decode("utf-8").split("doc:")[1]
-                metadata_raw = data.get(b"metadata", b"{}").decode("utf-8")  
-                metadata = json.loads(metadata_raw)
-                content = data.get(b"content", b"").decode("utf-8")
-                embedding_bytes = data.get(b"embedding")
-                if embedding_bytes:
-                    embedding = Vector(value=np.frombuffer(embedding_bytes, dtype=np.float32).tolist())
-                else:
-                    embedding = None
-                document = Document(
-                    id=doc_id,
-                    content=content,
-                    metadata=metadata,
-                    embedding=embedding
-                )
-                documents.append(document)
-        return documents
-
-    def delete_document(self, id: str) -> None:
-        doc_key = self._doc_key(id)
-        self._redis_client.delete(doc_key)
-
-    def update_document(self, document: Document) -> None:
-        doc_key = self._doc_key(document.id)
-        if not self._redis_client.exists(doc_key):
-            raise ValueError(f"Document with id {document.id} does not exist.")
-        # Update the document by re-adding it
-        self.add_documents([document])
-        
-
-    def cosine_similarity(self, vec1, vec2):
-        dot_product = np.dot(vec1, vec2)
-        norm_vec1 = np.linalg.norm(vec1)
-        norm_vec2 = np.linalg.norm(vec2)
-        if norm_vec1 == 0 or norm_vec2 == 0:
-            return 0
-        return dot_product / (norm_vec1 * norm_vec2)
-
-
-    def retrieve(self, query: str, top_k: int = 5) -> List[Document]:
-        query_vector = self._embedder.infer_vector(query)
-            
-        all_documents = self.get_all_documents()
-        # print("ALL DOCUMENTS ::::::::::::::::::::", all_documents[:10])
-        similarities = []
-        for doc in all_documents:
-            if doc.embedding is not None:
-                doc_vector = doc.embedding
-                # print("DOC VECTOR ::::::::::::::::::::", doc_vector.value[:10])
-                similarity = self.cosine_similarity(query_vector.value, doc_vector.value)
-                similarities.append((doc, similarity))
-        
-        similarities.sort(key=lambda x: x[1], reverse=True)
-        # print("SIMILARITIES ::::::::::::::::::::", similarities[:10])
-        top_documents = [doc for doc, _ in similarities[:top_k]]
-        # print(f"Found {len(top_documents)} similar documents.")
-        return top_documents
-        
-    
-    class Config:
-        extra = 'allow'
+import json
+from typing import List, Literal, Optional, Union
+
+import numpy as np
+import redis
+from pydantic import PrivateAttr
+from redis.commands.search.field import TextField, VectorField
+from redis.commands.search.indexDefinition import IndexDefinition, IndexType
+from swarmauri_base.vector_stores.VectorStoreBase import VectorStoreBase
+from swarmauri_base.vector_stores.VectorStoreRetrieveMixin import (
+    VectorStoreRetrieveMixin,
+)
+from swarmauri_base.vector_stores.VectorStoreSaveLoadMixin import (
+    VectorStoreSaveLoadMixin,
+)
+from swarmauri_base.ComponentBase import ComponentBase
+from swarmauri_embedding_doc2vec.Doc2VecEmbedding import Doc2VecEmbedding
+from swarmauri_standard.documents.Document import Document
+from swarmauri_standard.vectors.Vector import Vector
+
+
+@ComponentBase.register_type(VectorStoreBase, "RedisVectorStore")
+class RedisVectorStore(
+    VectorStoreSaveLoadMixin, VectorStoreRetrieveMixin, VectorStoreBase
+):
+    type: Literal["RedisVectorStore"] = "RedisVectorStore"
+    index_name: str = "documents_index"
+    embedding_dimension: int = 8000  # Default embedding dimension
+
+    # Private attributes
+    _embedder: Doc2VecEmbedding = PrivateAttr()
+    _redis_client: Optional[redis.Redis] = PrivateAttr(default=None)
+
+    # Configuration attributes with default values
+    redis_host: str = "localhost"
+    redis_port: int = 6379
+    redis_password: Optional[str] = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._embedder = Doc2VecEmbedding(vector_size=self.embedding_dimension)
+
+        # Initialize Redis client using class attributes
+        self.connect()
+
+        # Setup Redis Search index
+        vector_field = VectorField(
+            "embedding",
+            "FLAT",
+            {
+                "TYPE": "FLOAT32",
+                "DIM": self.embedding_dimension,
+                "DISTANCE_METRIC": "COSINE",
+            },
+        )
+        text_field = TextField("content")
+
+        try:
+            self._redis_client.ft(self.index_name).info()
+            print(f"Index '{self.index_name}' exists.")
+        except Exception:
+            print(f"Index '{self.index_name}' does not exist. Creating index...")
+            schema = (text_field, vector_field)
+            definition = IndexDefinition(prefix=["doc:"], index_type=IndexType.HASH)
+            self._redis_client.ft(self.index_name).create_index(
+                fields=schema, definition=definition
+            )
+            print(f"Index '{self.index_name}' created successfully.")
+
+    def connect(self) -> None:
+        """
+        Establishes a connection to the Redis server using class attributes.
+        """
+        try:
+            self._redis_client = redis.Redis(
+                host=self.redis_host,
+                port=self.redis_port,
+                password=self.redis_password,
+                decode_responses=False,  # For binary data
+            )
+            # Test the connection
+            self._redis_client.ping()
+            print("Connected to Redis successfully.")
+        except Exception as e:
+            print(f"Failed to connect to Redis: {e}")
+            raise
+
+    def disconnect(self) -> None:
+        """
+        Disconnects from the Redis server.
+        """
+        if self._redis_client:
+            self._redis_client.close()
+            self._redis_client = None
+            print("Disconnected from Redis.")
+
+    def _doc_key(self, document_id: str) -> str:
+        return f"doc:{document_id}"
+
+    def add_document(self, document: Document) -> None:
+        doc = document
+        pipeline = self._redis_client.pipeline()
+
+        # Embed the document content
+        embedding = self._embedder.fit_transform([doc.content])[0]
+
+        if isinstance(embedding, Vector):
+            embedding = embedding.value
+        metadata = doc.metadata
+
+        # print("METADATA ::::::::::::::::::::", metadata)
+        doc_key = self._doc_key(doc.id)
+        # print("DOC KEY ::::::::::::::::::::", doc_key)
+        pipeline.hset(
+            doc_key,
+            mapping={
+                "content": doc.content,
+                "metadata": json.dumps(metadata),  # Store metadata as JSON
+                "embedding": np.array(
+                    embedding, dtype=np.float32
+                ).tobytes(),  # Convert embedding values to bytes
+            },
+        )
+        pipeline.execute()
+
+    def add_documents(self, documents: List[Document]) -> None:
+        pipeline = self._redis_client.pipeline()
+        for doc in documents:
+            if not doc.content:
+                continue
+            # Embed the document content
+            embedding = self._embedder.fit_transform([doc.content])[0]
+
+            if isinstance(embedding, Vector):
+                embedding = embedding.value
+            metadata = {doc.metadata}
+
+            doc_key = self._doc_key(doc.id)
+            pipeline.hset(
+                doc_key,
+                mapping={
+                    "content": doc.content,
+                    "metadata": json.dumps(metadata),
+                    "embedding": np.array(embedding, dtype=np.float32).tobytes(),
+                },
+            )
+        pipeline.execute()
+
+    def get_document(self, id: str) -> Union[Document, None]:
+        doc_key = self._doc_key(id)
+        data = self._redis_client.hgetall(doc_key)
+        if not data:
+            return None
+
+        metadata_raw = data.get(b"metadata", b"{}").decode("utf-8")
+        metadata = json.loads(metadata_raw)
+
+        content = data.get(b"content", b"").decode("utf-8")
+        # print("METAAAAAAA ::::::::::::", metadata)
+
+        embedding_bytes = data.get(b"embedding")
+        if embedding_bytes:
+            embedding = Vector(
+                value=np.frombuffer(embedding_bytes, dtype=np.float32).tolist()
+            )
+        else:
+            embedding = None
+        return Document(id=id, content=content, metadata=metadata, embedding=embedding)
+
+    def get_all_documents(self) -> List[Document]:
+        cursor = "0"
+        documents = []
+        while cursor != 0:
+            cursor, keys = self._redis_client.scan(
+                cursor=cursor, match="doc:*", count=1000
+            )
+            for key in keys:
+                data = self._redis_client.hgetall(key)
+                if not data:
+                    continue
+                doc_id = key.decode("utf-8").split("doc:")[1]
+                metadata_raw = data.get(b"metadata", b"{}").decode("utf-8")
+                metadata = json.loads(metadata_raw)
+                content = data.get(b"content", b"").decode("utf-8")
+                embedding_bytes = data.get(b"embedding")
+                if embedding_bytes:
+                    embedding = Vector(
+                        value=np.frombuffer(embedding_bytes, dtype=np.float32).tolist()
+                    )
+                else:
+                    embedding = None
+                document = Document(
+                    id=doc_id, content=content, metadata=metadata, embedding=embedding
+                )
+                documents.append(document)
+        return documents
+
+    def delete_document(self, id: str) -> None:
+        doc_key = self._doc_key(id)
+        self._redis_client.delete(doc_key)
+
+    def update_document(self, document: Document) -> None:
+        doc_key = self._doc_key(document.id)
+        if not self._redis_client.exists(doc_key):
+            raise ValueError(f"Document with id {document.id} does not exist.")
+        # Update the document by re-adding it
+        self.add_documents([document])
+
+    def cosine_similarity(self, vec1, vec2):
+        dot_product = np.dot(vec1, vec2)
+        norm_vec1 = np.linalg.norm(vec1)
+        norm_vec2 = np.linalg.norm(vec2)
+        if norm_vec1 == 0 or norm_vec2 == 0:
+            return 0
+        return dot_product / (norm_vec1 * norm_vec2)
+
+    def retrieve(self, query: str, top_k: int = 5) -> List[Document]:
+        query_vector = self._embedder.infer_vector(query)
+
+        all_documents = self.get_all_documents()
+        # print("ALL DOCUMENTS ::::::::::::::::::::", all_documents[:10])
+        similarities = []
+        for doc in all_documents:
+            if doc.embedding is not None:
+                doc_vector = doc.embedding
+                # print("DOC VECTOR ::::::::::::::::::::", doc_vector.value[:10])
+                similarity = self.cosine_similarity(
+                    query_vector.value, doc_vector.value
+                )
+                similarities.append((doc, similarity))
+
+        similarities.sort(key=lambda x: x[1], reverse=True)
+        # print("SIMILARITIES ::::::::::::::::::::", similarities[:10])
+        top_documents = [doc for doc, _ in similarities[:top_k]]
+        # print(f"Found {len(top_documents)} similar documents.")
+        return top_documents

swarmauri_vectorstore_redis/__init__.py

@@ -1,12 +1,17 @@
-from .RedisVectorStore import RedisVectorStore
-
-__version__ = "0.6.0.dev26"
-__long_desc__ = """
-
-# Swarmauri Redis VectorStore Plugin
-
-Visit us at: https://swarmauri.com
-Follow us at: https://github.com/swarmauri
-Star us at: https://github.com/swarmauri/swarmauri-sdk
-
-"""
+from .RedisVectorStore import RedisVectorStore
+from .RedisDocumentRetriever import RedisDocumentRetriever
+
+__all__ = ["RedisVectorStore", "RedisDocumentRetriever"]
+
+try:
+    # For Python 3.8 and newer
+    from importlib.metadata import version, PackageNotFoundError
+except ImportError:
+    # For older Python versions, use the backport
+    from importlib_metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("swarmauri_vectorstore_redis")
+except PackageNotFoundError:
+    # If the package is not installed (for example, during development)
+    __version__ = "0.0.0"

swarmauri_vectorstore_redis-0.7.0.dev3.dist-info/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2025] [Jacob Stewart @ Swarmauri]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

swarmauri_vectorstore_redis-0.7.0.dev3.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.3
+Name: swarmauri_vectorstore_redis
+Version: 0.7.0.dev3
+Summary: Swarmauri Redis Vector Store
+License: Apache-2.0
+Author: Jacob Stewart
+Author-email: jacob@swarmauri.com
+Requires-Python: >=3.10,<3.13
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: redis (>=4.0)
+Requires-Dist: redisearch
+Requires-Dist: swarmauri_base
+Requires-Dist: swarmauri_core
+Requires-Dist: swarmauri_embedding_doc2vec
+Requires-Dist: swarmauri_standard
+Description-Content-Type: text/markdown
+
+![Swarmauri Logo](https://res.cloudinary.com/dbjmpekvl/image/upload/v1730099724/Swarmauri-logo-lockup-2048x757_hww01w.png)
+
+<div align="center">
+
+![PyPI - Downloads](https://img.shields.io/pypi/dm/swarmauri_vectorstore_redis)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/swarmauri_vectorstore_redis)
+![PyPI - License](https://img.shields.io/pypi/l/swarmauri_vectorstore_redis)
+![PyPI - Version](https://img.shields.io/pypi/v/swarmauri_vectorstore_redis?label=swarmauri_vectorstore_redis&color=green)
+
+</div>
+
+---
+
+# Redis Vector Store for Swarmauri
+
+A Redis-based vector store implementation for the Swarmauri SDK that enables efficient storage and retrieval of document embeddings.
+
+## Installation
+
+```bash
+pip install swarmauri_vectorstore_redis
+```
+
+## Usage
+
+Basic example of using RedisVectorStore:
+
+```python
+from swarmauri.vector_stores.RedisVectorStore import RedisVectorStore
+from swarmauri.documents.Document import Document
+
+# Initialize the vector store
+vector_store = RedisVectorStore(
+    redis_host="localhost",
+    redis_port=6379,
+    redis_password="your_password",
+    embedding_dimension=8000
+)
+
+# Add documents
+document = Document(
+    id="doc1",
+    content="Sample document content",
+    metadata={"category": "sample"}
+)
+vector_store.add_document(document)
+
+# Retrieve similar documents
+similar_docs = vector_store.retrieve("sample content", top_k=5)
+```
+
+## Want to help?
+
+If you want to contribute to swarmauri-sdk, read up on our [guidelines for contributing](https://github.com/swarmauri/swarmauri-sdk/blob/master/contributing.md) that will help you get started.
+
+

swarmauri_vectorstore_redis-0.7.0.dev3.dist-info/RECORD

@@ -0,0 +1,7 @@
+swarmauri_vectorstore_redis/RedisDocumentRetriever.py,sha256=KpyLF5ppV39resScSVnKmaI5GRGb-XFsIRu_NuVf5BA,2123
+swarmauri_vectorstore_redis/RedisVectorStore.py,sha256=AaHx_LXVaRv9673YZ7lxyD3zfsnQxNwi1e64M-jJDsA,8805
+swarmauri_vectorstore_redis/__init__.py,sha256=VZnPDlZSK6XwoXchn0goAHYqfS-f0RMJiYUFqkQjvOo,591
+swarmauri_vectorstore_redis-0.7.0.dev3.dist-info/LICENSE,sha256=djUXOlCxLVszShEpZXshZ7v33G-2qIC_j9KXpWKZSzQ,11359
+swarmauri_vectorstore_redis-0.7.0.dev3.dist-info/METADATA,sha256=qRrUhh-rHhByXX2D87OCuZsXpY8hkU7qNLyVnHt_QqI,2282
+swarmauri_vectorstore_redis-0.7.0.dev3.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+swarmauri_vectorstore_redis-0.7.0.dev3.dist-info/RECORD,,

{swarmauri_vectorstore_redis-0.6.0.dev154.dist-info → swarmauri_vectorstore_redis-0.7.0.dev3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.0.1
+Generator: poetry-core 2.1.1
 Root-Is-Purelib: true
 Tag: py3-none-any

swarmauri_vectorstore_redis-0.6.0.dev154.dist-info/METADATA

@@ -1,20 +0,0 @@
-Metadata-Version: 2.3
-Name: swarmauri_vectorstore_redis
-Version: 0.6.0.dev154
-Summary: Swarmauri Redis Vector Store
-License: Apache-2.0
-Author: Jacob Stewart
-Author-email: jacob@swarmauri.com
-Requires-Python: >=3.10,<3.13
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: redis (>=4.0,<5.0)
-Requires-Dist: swarmauri_base (>=0.6.0.dev154,<0.7.0)
-Requires-Dist: swarmauri_core (>=0.6.0.dev154,<0.7.0)
-Project-URL: Repository, http://github.com/swarmauri/swarmauri-sdk
-Description-Content-Type: text/markdown
-
-# Swarmauri Example Community Package

swarmauri_vectorstore_redis-0.6.0.dev154.dist-info/RECORD

@@ -1,7 +0,0 @@
-swarmauri_vectorstore_redis/__init__.py,sha256=kEer1rPuqj3_CAoRTjOr9-nBY7Dz6n__w_kXSddD6u4,285
-swarmauri_vectorstore_redis/RedisDocumentRetriever.py,sha256=5x62kZ2a7H8qoHzOttNnpg3WlKoyL6FyCuR8PlEm_SU,2234
-swarmauri_vectorstore_redis/RedisVectorStore.py,sha256=cmckLjTsg1qxvqojom3VZW41tIg8bOlkWPt4l1Ufsug,9121
-swarmauri_vectorstore_redis-0.6.0.dev154.dist-info/entry_points.txt,sha256=HSN4TqGUlAgs7ovkyK0DCa0k4MoQkF2irfPAPjIw9kU,227
-swarmauri_vectorstore_redis-0.6.0.dev154.dist-info/METADATA,sha256=djVzFMQXuV4whFaQwpCTeFSMKKeqrm9qmbXPgDl0hFM,774
-swarmauri_vectorstore_redis-0.6.0.dev154.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-swarmauri_vectorstore_redis-0.6.0.dev154.dist-info/RECORD,,

swarmauri_vectorstore_redis-0.6.0.dev154.dist-info/entry_points.txt

@@ -1,6 +0,0 @@
-[swarmauri.retrievers]
-RedisDocumentRetriever=swarmauri_vectorstore_redis.RedisDocumentRetriever:RedisDocumentRetriever
-
-[swarmauri.vector_stores]
-RedisVectorStore=swarmauri_vectorstore_redis.RedisVectorStore:RedisVectorStore
-