loci-memory 0.0.2__tar.gz

loci_memory-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2026] [Daniel Roque Gonçalves de Almeida]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

loci_memory-0.0.2/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: loci-memory
+Version: 0.0.2
+Summary: Chroma based MCP Server - Provide memory capabilities using Vector Database for LLM Applications
+License-Expression: MIT
+Keywords: chroma,mcp,vector-database,llm,memory
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: chromadb>=1.0.16
+Requires-Dist: fastmcp>=3.2.3
+Requires-Dist: typing-extensions>=4.13.1
+Dynamic: license-file
+
+## Features
+
+- **Flexible Client Types**
+  - Ephemeral (in-memory) for testing and development
+  - Persistent for file-based storage
+
+- **Collection Management**
+  - Create, modify, and delete collections
+  - List all collections with pagination support
+  - Get collection information and statistics
+  - Configure HNSW parameters for optimized vector search
+  - Select embedding functions when creating collections
+
+- **Document Operations**
+  - Add documents with optional metadata and custom IDs
+  - Query documents using semantic search
+  - Advanced filtering using metadata and document content
+  - Retrieve documents by IDs or filters
+  - Full text search capabilities
+
+### Supported Tools
+
+- `chroma_list_collections` - List all collections with pagination support
+- `chroma_create_collection` - Create a new collection with optional HNSW configuration
+- `chroma_peek_collection` - View a sample of documents in a collection
+- `chroma_get_collection_info` - Get detailed information about a collection
+- `chroma_get_collection_count` - Get the number of documents in a collection
+- `chroma_modify_collection` - Update a collection's name or metadata
+- `chroma_delete_collection` - Delete a collection
+- `chroma_add_documents` - Add documents with optional metadata and custom IDs
+- `chroma_query_documents` - Query documents using semantic search with advanced filtering
+- `chroma_get_documents` - Retrieve documents by IDs or filters with pagination
+- `chroma_update_documents` - Update existing documents' content, metadata, or embeddings
+- `chroma_delete_documents` - Delete specific documents from a collection
+
+### Embedding Functions
+Chroma MCP supports several embedding functions: `default`, `cohere`, `openai`, `jina`, `voyageai`, and `roboflow`.
+
+The embedding functions utilize Chroma's collection configuration, which persists the selected embedding function of a collection for retrieval. Once a collection is created using the collection configuration, on retrieval for future queries and inserts, the same embedding function will be used, without needing to specify the embedding function again. Embedding function persistance was added in v1.0.0 of Chroma, so if you created a collection using version <=0.6.3, this feature is not supported.
+
+When accessing embedding functions that utilize external APIs, please be sure to add the environment variable for the API key with the correct format, found in [Embedding Function Environment Variables](#embedding-function-environment-variables)
+
+## Usage with LM Studio
+
+Add the following to your `mcp.json` file:
+
+```json
+"chroma": {
+    "command": "uvx",
+    "args": [
+        "loci-memory",
+        "--client-type",
+        "persistent",
+        "--data-dir",
+        "/full/path/to/your/data/directory"
+    ]
+}
+
+[GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/)

loci_memory-0.0.2/README.md

@@ -0,0 +1,59 @@
+## Features
+
+- **Flexible Client Types**
+  - Ephemeral (in-memory) for testing and development
+  - Persistent for file-based storage
+
+- **Collection Management**
+  - Create, modify, and delete collections
+  - List all collections with pagination support
+  - Get collection information and statistics
+  - Configure HNSW parameters for optimized vector search
+  - Select embedding functions when creating collections
+
+- **Document Operations**
+  - Add documents with optional metadata and custom IDs
+  - Query documents using semantic search
+  - Advanced filtering using metadata and document content
+  - Retrieve documents by IDs or filters
+  - Full text search capabilities
+
+### Supported Tools
+
+- `chroma_list_collections` - List all collections with pagination support
+- `chroma_create_collection` - Create a new collection with optional HNSW configuration
+- `chroma_peek_collection` - View a sample of documents in a collection
+- `chroma_get_collection_info` - Get detailed information about a collection
+- `chroma_get_collection_count` - Get the number of documents in a collection
+- `chroma_modify_collection` - Update a collection's name or metadata
+- `chroma_delete_collection` - Delete a collection
+- `chroma_add_documents` - Add documents with optional metadata and custom IDs
+- `chroma_query_documents` - Query documents using semantic search with advanced filtering
+- `chroma_get_documents` - Retrieve documents by IDs or filters with pagination
+- `chroma_update_documents` - Update existing documents' content, metadata, or embeddings
+- `chroma_delete_documents` - Delete specific documents from a collection
+
+### Embedding Functions
+Chroma MCP supports several embedding functions: `default`, `cohere`, `openai`, `jina`, `voyageai`, and `roboflow`.
+
+The embedding functions utilize Chroma's collection configuration, which persists the selected embedding function of a collection for retrieval. Once a collection is created using the collection configuration, on retrieval for future queries and inserts, the same embedding function will be used, without needing to specify the embedding function again. Embedding function persistance was added in v1.0.0 of Chroma, so if you created a collection using version <=0.6.3, this feature is not supported.
+
+When accessing embedding functions that utilize external APIs, please be sure to add the environment variable for the API key with the correct format, found in [Embedding Function Environment Variables](#embedding-function-environment-variables)
+
+## Usage with LM Studio
+
+Add the following to your `mcp.json` file:
+
+```json
+"chroma": {
+    "command": "uvx",
+    "args": [
+        "loci-memory",
+        "--client-type",
+        "persistent",
+        "--data-dir",
+        "/full/path/to/your/data/directory"
+    ]
+}
+
+[GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/)

loci_memory-0.0.2/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "loci-memory"
+version = "0.0.2"
+description = "Chroma based MCP Server - Provide memory capabilities using Vector Database for LLM Applications"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+
+keywords = ["chroma", "mcp", "vector-database", "llm", "memory"]
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules"
+]
+
+dependencies = [
+    "chromadb>=1.0.16",
+    "fastmcp>=3.2.3",
+    "typing-extensions>=4.13.1",
+]

loci_memory-0.0.2/setup.cfg

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

loci_memory-0.0.2/src/loci-memory/loci-memory.py

@@ -0,0 +1,599 @@
+# loci-memory.py
+from typing import Dict, List, TypedDict, Union
+from mcp.server.fastmcp import FastMCP          #   Framework for building MCP Applications
+import chromadb
+import os                                       #   Python os Module
+import argparse                                 #   Argument parser
+
+from chromadb.api.collection_configuration import (
+    CreateCollectionConfiguration
+    )
+from chromadb.api import EmbeddingFunction
+from chromadb.utils.embedding_functions import (
+    DefaultEmbeddingFunction,
+    CohereEmbeddingFunction,
+    OpenAIEmbeddingFunction,
+    JinaEmbeddingFunction,
+    VoyageAIEmbeddingFunction,
+    RoboflowEmbeddingFunction,
+)
+
+# Create an MCP server
+mcp = FastMCP(
+        "LOCI",
+        instructions="Provides memory capabilities to an LLM. Start with get_summary() for an overview.")
+
+# Global variables
+_chroma_client = None
+
+#
+#   Create Parser
+#
+def create_parser():
+    """Create and return the argument parser."""
+    parser = argparse.ArgumentParser(description='FastMCP server for Chroma DB')
+    parser.add_argument('--client-type', 
+                       choices=['persistent', 'ephemeral'],
+                       default=os.getenv('CHROMA_CLIENT_TYPE', 'ephemeral'),
+                       help='Type of Chroma client to use')
+    parser.add_argument('--data-dir',
+                       default=os.getenv('CHROMA_DATA_DIR'),
+                       help='Directory for persistent client data (only used with persistent client)')
+    return parser
+
+#
+#   Get Chroma Client
+#
+def get_chroma_client(args=None):
+    """Get or create the global Chroma client instance."""
+    global _chroma_client
+    if _chroma_client is None:
+        if args is None:
+            # Create parser and parse args if not provided
+            parser = create_parser()
+            args = parser.parse_args()
+
+        if args.client_type == 'persistent':
+            if not args.data_dir:
+                raise ValueError("Data directory must be provided via --data-dir flag when using persistent client")
+            _chroma_client = chromadb.PersistentClient(path=args.data_dir)
+        else:  # ephemeral
+            _chroma_client = chromadb.EphemeralClient()
+
+    return _chroma_client
+
+
+@mcp.tool()
+async def chroma_list_collections(
+    limit: int | None = None,
+    offset: int | None = None
+) -> List[str]:
+    """List all collection names in the Chroma database with pagination support.
+    
+    Args:
+        limit: Optional maximum number of collections to return
+        offset: Optional number of collections to skip before returning results
+    
+    Returns:
+        List of collection names or ["__NO_COLLECTIONS_FOUND__"] if database is empty
+    """
+    client = get_chroma_client()
+    try:
+        colls = client.list_collections(limit=limit, offset=offset)
+        # Safe handling: If colls is None or empty, return a special marker
+        if not colls:
+            return ["__NO_COLLECTIONS_FOUND__"]
+        # Otherwise iterate to get collection names
+        return [coll.name for coll in colls]
+
+    except Exception as e:
+        raise Exception(f"Failed to list collections: {str(e)}") from e
+
+#
+#   Declare a variable with common embedding functions
+#
+mcp_embedding_functions: Dict[str, EmbeddingFunction] = {
+    "default": DefaultEmbeddingFunction,
+    "cohere": CohereEmbeddingFunction,
+    "openai": OpenAIEmbeddingFunction,
+    "jina": JinaEmbeddingFunction,
+    "voyageai": VoyageAIEmbeddingFunction,
+    "roboflow": RoboflowEmbeddingFunction,
+}
+
+@mcp.tool()
+async def chroma_create_collection(
+    collection_name: str,
+    embedding_function_name: str = "default",
+    metadata: Dict | None = None,
+) -> str:
+    """Create a new Chroma collection with configurable HNSW parameters.
+    
+    Args:
+        collection_name: Name of the collection to create
+        embedding_function_name: Name of the embedding function to use. Options: 'default', 'cohere', 'openai', 'jina', 'voyageai', 'ollama', 'roboflow'
+        metadata: Optional metadata dict to add to the collection
+    """
+    client = get_chroma_client()
+    
+    embedding_function = mcp_embedding_functions[embedding_function_name]
+    
+    configuration=CreateCollectionConfiguration(
+        embedding_function=embedding_function()
+    )
+    
+    try:
+        client.create_collection(
+            name=collection_name,
+            configuration=configuration,
+            metadata=metadata
+        )
+        config_msg = f" with configuration: {configuration}"
+        return f"Successfully created collection {collection_name}{config_msg}"
+    except Exception as e:
+        raise Exception(f"Failed to create collection '{collection_name}': {str(e)}") from e
+
+@mcp.tool()
+async def chroma_peek_collection(
+    collection_name: str,
+    limit: int = 5
+) -> Dict:
+    """Peek at documents in a Chroma collection.
+    
+    Args:
+        collection_name: Name of the collection to peek into
+        limit: Number of documents to peek at
+    """
+    client = get_chroma_client()
+    try:
+        collection = client.get_collection(collection_name)
+        results = collection.peek(limit=limit)
+        return results
+    except Exception as e:
+        raise Exception(f"Failed to peek collection '{collection_name}': {str(e)}") from e
+
+@mcp.tool()
+async def chroma_get_collection_info(collection_name: str) -> Dict:
+    """Get information about a Chroma collection.
+    
+    Args:
+        collection_name: Name of the collection to get info about
+    """
+    client = get_chroma_client()
+    try:
+        collection = client.get_collection(collection_name)
+        
+        # Get collection count
+        count = collection.count()
+        
+        # Peek at a few documents
+        peek_results = collection.peek(limit=3)
+        
+        return {
+            "name": collection_name,
+            "count": count,
+            "sample_documents": peek_results
+        }
+    except Exception as e:
+        raise Exception(f"Failed to get collection info for '{collection_name}': {str(e)}") from e
+    
+@mcp.tool()
+async def chroma_get_collection_count(collection_name: str) -> int:
+    """Get the number of documents in a Chroma collection.
+    
+    Args:
+        collection_name: Name of the collection to count
+    """
+    client = get_chroma_client()
+    try:
+        collection = client.get_collection(collection_name)
+        return collection.count()
+    except Exception as e:
+        raise Exception(f"Failed to get collection count for '{collection_name}': {str(e)}") from e
+
+@mcp.tool()
+async def chroma_modify_collection(
+    collection_name: str,
+    new_name: str | None = None,
+    new_metadata: Dict | None = None,
+) -> str:
+    """Modify a Chroma collection's name or metadata.
+    
+    Args:
+        collection_name: Name of the collection to modify
+        new_name: Optional new name for the collection
+        new_metadata: Optional new metadata for the collection
+    """
+    client = get_chroma_client()
+    try:
+        collection = client.get_collection(collection_name)
+        collection.modify(name=new_name, metadata=new_metadata)
+        
+        modified_aspects = []
+        if new_name:
+            modified_aspects.append("name")
+        if new_metadata:
+            modified_aspects.append("metadata")
+        
+        return f"Successfully modified collection {collection_name}: updated {' and '.join(modified_aspects)}"
+    except Exception as e:
+        raise Exception(f"Failed to modify collection '{collection_name}': {str(e)}") from e
+    
+@mcp.tool()
+async def chroma_fork_collection(
+    collection_name: str,
+    new_collection_name: str,
+) -> str:
+    """Fork a Chroma collection.
+    
+    Args:
+        collection_name: Name of the collection to fork
+        new_collection_name: Name of the new collection to create
+        metadata: Optional metadata dict to add to the new collection
+    """
+    client = get_chroma_client()
+    try:
+        collection = client.get_collection(collection_name)
+        collection.fork(new_collection_name)
+        return f"Successfully forked collection {collection_name} to {new_collection_name}"
+    except Exception as e:
+        raise Exception(f"Failed to fork collection '{collection_name}': {str(e)}") from e
+    
+@mcp.tool()
+async def chroma_delete_collection(collection_name: str) -> str:
+    """Delete a Chroma collection.
+    
+    Args:
+        collection_name: Name of the collection to delete
+    """
+    client = get_chroma_client()
+    try:
+        client.delete_collection(collection_name)
+        return f"Successfully deleted collection {collection_name}"
+    except Exception as e:
+        raise Exception(f"Failed to delete collection '{collection_name}': {str(e)}") from e
+
+##### Document Tools #####
+@mcp.tool()
+async def chroma_add_documents(
+    collection_name: str,
+    documents: List[str],
+    ids: List[str],
+    metadatas: List[Dict] | None = None
+) -> str:
+    """Add documents to a Chroma collection.
+    
+    Args:
+        collection_name: Name of the collection to add documents to
+        documents: List of text documents to add
+        ids: List of IDs for the documents (required)
+        metadatas: Optional list of metadata dictionaries for each document
+    """
+    if not documents:
+        raise ValueError("The 'documents' list cannot be empty.")
+    
+    if not ids:
+        raise ValueError("The 'ids' list is required and cannot be empty.")
+    
+    # Check if there are empty strings in the ids list
+    if any(not id.strip() for id in ids):
+        raise ValueError("IDs cannot be empty strings.")
+    
+    if len(ids) != len(documents):
+        raise ValueError(f"Number of ids ({len(ids)}) must match number of documents ({len(documents)}).")
+
+    client = get_chroma_client()
+    try:
+        collection = client.get_or_create_collection(collection_name)
+        
+        # Check for duplicate IDs
+        existing_ids = collection.get(include=[])["ids"]
+        duplicate_ids = [id for id in ids if id in existing_ids]
+        
+        if duplicate_ids:
+            raise ValueError(
+                f"The following IDs already exist in collection '{collection_name}': {duplicate_ids}. "
+                f"Use 'chroma_update_documents' to update existing documents."
+            )
+        
+        result = collection.add(
+            documents=documents,
+            metadatas=metadatas,
+            ids=ids
+        )
+        
+        # Check the return value
+        if result and isinstance(result, dict):
+            # If the return value is a dictionary, it may contain success information
+            if 'success' in result and not result['success']:
+                raise Exception(f"Failed to add documents: {result.get('error', 'Unknown error')}")
+            
+            # If the return value contains the actual number added
+            if 'count' in result:
+                return f"Successfully added {result['count']} documents to collection {collection_name}"
+        
+        # Default return
+        return f"Successfully added {len(documents)} documents to collection {collection_name}, result is {result}"
+    except Exception as e:
+        raise Exception(f"Failed to add documents to collection '{collection_name}': {str(e)}") from e
+
+@mcp.tool()
+async def chroma_query_documents(
+    collection_name: str,
+    query_texts: List[str],
+    n_results: int = 5,
+    where: Dict | None = None,
+    where_document: Dict | None = None,
+    include: List[str] = ["documents", "metadatas", "distances"]
+) -> Dict:
+    """Query documents from a Chroma collection with advanced filtering.
+    
+    Args:
+        collection_name: Name of the collection to query
+        query_texts: List of query texts to search for
+        n_results: Number of results to return per query
+        where: Optional metadata filters using Chroma's query operators
+               Examples:
+               - Simple equality: {"metadata_field": "value"}
+               - Comparison: {"metadata_field": {"$gt": 5}}
+               - Logical AND: {"$and": [{"field1": {"$eq": "value1"}}, {"field2": {"$gt": 5}}]}
+               - Logical OR: {"$or": [{"field1": {"$eq": "value1"}}, {"field1": {"$eq": "value2"}}]}
+        where_document: Optional document content filters
+               Examples:
+               - Contains: {"$contains": "value"}
+               - Not contains: {"$not_contains": "value"}
+               - Regex: {"$regex": "[a-z]+"}
+               - Not regex: {"$not_regex": "[a-z]+"}
+               - Logical AND: {"$and": [{"$contains": "value1"}, {"$not_regex": "[a-z]+"}]}
+               - Logical OR: {"$or": [{"$regex": "[a-z]+"}, {"$not_contains": "value2"}]}
+        include: List of what to include in response. By default, this will include documents, metadatas, and distances.
+    """
+    if not query_texts:
+        raise ValueError("The 'query_texts' list cannot be empty.")
+
+    client = get_chroma_client()
+    try:
+        collection = client.get_collection(collection_name)
+        return collection.query(
+            query_texts=query_texts,
+            n_results=n_results,
+            where=where,
+            where_document=where_document,
+            include=include
+        )
+    except Exception as e:
+        raise Exception(f"Failed to query documents from collection '{collection_name}': {str(e)}") from e
+
+@mcp.tool()
+async def chroma_get_documents(
+    collection_name: str,
+    ids: List[str] | None = None,
+    where: Dict | None = None,
+    where_document: Dict | None = None,
+    include: List[str] = ["documents", "metadatas"],
+    limit: int | None = None,
+    offset: int | None = None
+) -> Dict:
+    """Get documents from a Chroma collection with optional filtering.
+    
+    Args:
+        collection_name: Name of the collection to get documents from
+        ids: Optional list of document IDs to retrieve
+        where: Optional metadata filters using Chroma's query operators
+               Examples:
+               - Simple equality: {"metadata_field": "value"}
+               - Comparison: {"metadata_field": {"$gt": 5}}
+               - Logical AND: {"$and": [{"field1": {"$eq": "value1"}}, {"field2": {"$gt": 5}}]}
+               - Logical OR: {"$or": [{"field1": {"$eq": "value1"}}, {"field1": {"$eq": "value2"}}]}
+        where_document: Optional document content filters
+               Examples:
+               - Contains: {"$contains": "value"}
+               - Not contains: {"$not_contains": "value"}
+               - Regex: {"$regex": "[a-z]+"}
+               - Not regex: {"$not_regex": "[a-z]+"}
+               - Logical AND: {"$and": [{"$contains": "value1"}, {"$not_regex": "[a-z]+"}]}
+               - Logical OR: {"$or": [{"$regex": "[a-z]+"}, {"$not_contains": "value2"}]}
+        include: List of what to include in response. By default, this will include documents, and metadatas.
+        limit: Optional maximum number of documents to return
+        offset: Optional number of documents to skip before returning results
+    
+    Returns:
+        Dictionary containing the matching documents, their IDs, and requested includes
+    """
+    client = get_chroma_client()
+    try:
+        collection = client.get_collection(collection_name)
+        return collection.get(
+            ids=ids,
+            where=where,
+            where_document=where_document,
+            include=include,
+            limit=limit,
+            offset=offset
+        )
+    except Exception as e:
+        raise Exception(f"Failed to get documents from collection '{collection_name}': {str(e)}") from e
+
+@mcp.tool()
+async def chroma_update_documents(
+    collection_name: str,
+    ids: List[str],
+    embeddings: List[List[float]] | None = None,
+    metadatas: List[Dict] | None = None,
+    documents: List[str] | None = None
+) -> str:
+    """Update documents in a Chroma collection.
+
+    Args:
+        collection_name: Name of the collection to update documents in
+        ids: List of document IDs to update (required)
+        embeddings: Optional list of new embeddings for the documents.
+                    Must match length of ids if provided.
+        metadatas: Optional list of new metadata dictionaries for the documents.
+                   Must match length of ids if provided.
+        documents: Optional list of new text documents.
+                   Must match length of ids if provided.
+
+    Returns:
+        A confirmation message indicating the number of documents updated.
+
+    Raises:
+        ValueError: If 'ids' is empty or if none of 'embeddings', 'metadatas',
+                    or 'documents' are provided, or if the length of provided
+                    update lists does not match the length of 'ids'.
+        Exception: If the collection does not exist or if the update operation fails.
+    """
+    if not ids:
+        raise ValueError("The 'ids' list cannot be empty.")
+
+    if embeddings is None and metadatas is None and documents is None:
+        raise ValueError(
+            "At least one of 'embeddings', 'metadatas', or 'documents' "
+            "must be provided for update."
+        )
+
+    # Ensure provided lists match the length of ids if they are not None
+    if embeddings is not None and len(embeddings) != len(ids):
+        raise ValueError("Length of 'embeddings' list must match length of 'ids' list.")
+    if metadatas is not None and len(metadatas) != len(ids):
+        raise ValueError("Length of 'metadatas' list must match length of 'ids' list.")
+    if documents is not None and len(documents) != len(ids):
+        raise ValueError("Length of 'documents' list must match length of 'ids' list.")
+
+
+    client = get_chroma_client()
+    try:
+        collection = client.get_collection(collection_name)
+    except Exception as e:
+        raise Exception(
+            f"Failed to get collection '{collection_name}': {str(e)}"
+        ) from e
+
+    # Prepare arguments for update, excluding None values at the top level
+    update_args = {
+        "ids": ids,
+        "embeddings": embeddings,
+        "metadatas": metadatas,
+        "documents": documents,
+    }
+    kwargs = {k: v for k, v in update_args.items() if v is not None}
+
+    try:
+        collection.update(**kwargs)
+        return (
+            f"Successfully processed update request for {len(ids)} documents in "
+            f"collection '{collection_name}'. Note: Non-existent IDs are ignored by ChromaDB."
+        )
+    except Exception as e:
+        raise Exception(
+            f"Failed to update documents in collection '{collection_name}': {str(e)}"
+        ) from e
+
+@mcp.tool()
+async def chroma_delete_documents(
+    collection_name: str,
+    ids: List[str]
+) -> str:
+    """Delete documents from a Chroma collection.
+
+    Args:
+        collection_name: Name of the collection to delete documents from
+        ids: List of document IDs to delete
+
+    Returns:
+        A confirmation message indicating the number of documents deleted.
+
+    Raises:
+        ValueError: If 'ids' is empty
+        Exception: If the collection does not exist or if the delete operation fails.
+    """
+    if not ids:
+        raise ValueError("The 'ids' list cannot be empty.")
+
+    client = get_chroma_client()
+    try:
+        collection = client.get_collection(collection_name)
+    except Exception as e:
+        raise Exception(
+            f"Failed to get collection '{collection_name}': {str(e)}"
+        ) from e
+
+    try:
+        collection.delete(ids=ids)
+        return (
+            f"Successfully deleted {len(ids)} documents from "
+            f"collection '{collection_name}'. Note: Non-existent IDs are ignored by ChromaDB."
+        )
+    except Exception as e:
+        raise Exception(
+            f"Failed to delete documents from collection '{collection_name}': {str(e)}"
+        ) from e
+
+def validate_thought_data(input_data: Dict) -> Dict:
+    """Validate thought data structure."""
+    if not input_data.get("sessionId"):
+        raise ValueError("Invalid sessionId: must be provided")
+    if not input_data.get("thought") or not isinstance(input_data.get("thought"), str):
+        raise ValueError("Invalid thought: must be a string")
+    if not input_data.get("thoughtNumber") or not isinstance(input_data.get("thoughtNumber"), int):
+            raise ValueError("Invalid thoughtNumber: must be a number")
+    if not input_data.get("totalThoughts") or not isinstance(input_data.get("totalThoughts"), int):
+        raise ValueError("Invalid totalThoughts: must be a number")
+    if not isinstance(input_data.get("nextThoughtNeeded"), bool):
+        raise ValueError("Invalid nextThoughtNeeded: must be a boolean")
+        
+    return {
+        "sessionId": input_data.get("sessionId"),
+        "thought": input_data.get("thought"),
+        "thoughtNumber": input_data.get("thoughtNumber"),
+        "totalThoughts": input_data.get("totalThoughts"),
+        "nextThoughtNeeded": input_data.get("nextThoughtNeeded"),
+        "isRevision": input_data.get("isRevision"),
+        "revisesThought": input_data.get("revisesThought"),
+        "branchFromThought": input_data.get("branchFromThought"),
+        "branchId": input_data.get("branchId"),
+        "needsMoreThoughts": input_data.get("needsMoreThoughts"),
+    }
+
+def main():
+    """Entry point for the Chroma MCP server."""
+    parser = create_parser()
+    args = parser.parse_args()
+       
+    # Initialize client with parsed args
+    try:
+        get_chroma_client(args)
+        print("Successfully initialized Chroma client")
+    except Exception as e:
+        print(f"Failed to initialize Chroma client: {str(e)}")
+        raise
+    
+    # Initialize and run the server
+    print("Starting MCP server")
+    mcp.run(transport='stdio')
+
+#
+#   Declare the tool set
+#
+"""
+@mcp.tool(
+   name="find_products",           # Custom tool name for the LLM
+    description="Search the product catalog with optional category filtering.", # Custom description
+    tags={"catalog", "search"},      # Optional tags for organization/filtering
+    meta={"version": "1.2", "author": "product-team"}  # Custom metadata
+)
+def test_test(
+query: str,
+max_results: int = 10,            # Optional - has default value
+category: str | None = None       # Optional - can be None
+) -> list[dict]:
+    "" "Internal function description (ignored if description is provided above)." ""
+    # Implementation...
+    print(f"Searching for '{query}' in category '{category}'")
+    return [{"id": 2, "name": "Another Product"}]
+"""
+
+if __name__ == "__main__":
+    mcp.run()
+    #mcp.run(transport="http", port=8000)               #          Run Web Version
+    #main()

loci_memory-0.0.2/src/loci_memory.egg-info/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: loci-memory
+Version: 0.0.2
+Summary: Chroma based MCP Server - Provide memory capabilities using Vector Database for LLM Applications
+License-Expression: MIT
+Keywords: chroma,mcp,vector-database,llm,memory
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: chromadb>=1.0.16
+Requires-Dist: fastmcp>=3.2.3
+Requires-Dist: typing-extensions>=4.13.1
+Dynamic: license-file
+
+## Features
+
+- **Flexible Client Types**
+  - Ephemeral (in-memory) for testing and development
+  - Persistent for file-based storage
+
+- **Collection Management**
+  - Create, modify, and delete collections
+  - List all collections with pagination support
+  - Get collection information and statistics
+  - Configure HNSW parameters for optimized vector search
+  - Select embedding functions when creating collections
+
+- **Document Operations**
+  - Add documents with optional metadata and custom IDs
+  - Query documents using semantic search
+  - Advanced filtering using metadata and document content
+  - Retrieve documents by IDs or filters
+  - Full text search capabilities
+
+### Supported Tools
+
+- `chroma_list_collections` - List all collections with pagination support
+- `chroma_create_collection` - Create a new collection with optional HNSW configuration
+- `chroma_peek_collection` - View a sample of documents in a collection
+- `chroma_get_collection_info` - Get detailed information about a collection
+- `chroma_get_collection_count` - Get the number of documents in a collection
+- `chroma_modify_collection` - Update a collection's name or metadata
+- `chroma_delete_collection` - Delete a collection
+- `chroma_add_documents` - Add documents with optional metadata and custom IDs
+- `chroma_query_documents` - Query documents using semantic search with advanced filtering
+- `chroma_get_documents` - Retrieve documents by IDs or filters with pagination
+- `chroma_update_documents` - Update existing documents' content, metadata, or embeddings
+- `chroma_delete_documents` - Delete specific documents from a collection
+
+### Embedding Functions
+Chroma MCP supports several embedding functions: `default`, `cohere`, `openai`, `jina`, `voyageai`, and `roboflow`.
+
+The embedding functions utilize Chroma's collection configuration, which persists the selected embedding function of a collection for retrieval. Once a collection is created using the collection configuration, on retrieval for future queries and inserts, the same embedding function will be used, without needing to specify the embedding function again. Embedding function persistance was added in v1.0.0 of Chroma, so if you created a collection using version <=0.6.3, this feature is not supported.
+
+When accessing embedding functions that utilize external APIs, please be sure to add the environment variable for the API key with the correct format, found in [Embedding Function Environment Variables](#embedding-function-environment-variables)
+
+## Usage with LM Studio
+
+Add the following to your `mcp.json` file:
+
+```json
+"chroma": {
+    "command": "uvx",
+    "args": [
+        "loci-memory",
+        "--client-type",
+        "persistent",
+        "--data-dir",
+        "/full/path/to/your/data/directory"
+    ]
+}
+
+[GitHub-flavored Markdown](https://guides.github.com/features/mastering-markdown/)

loci_memory-0.0.2/src/loci_memory.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/loci-memory/__init__.py
+src/loci-memory/loci-memory.py
+src/loci_memory.egg-info/PKG-INFO
+src/loci_memory.egg-info/SOURCES.txt
+src/loci_memory.egg-info/dependency_links.txt
+src/loci_memory.egg-info/requires.txt
+src/loci_memory.egg-info/top_level.txt

loci_memory-0.0.2/src/loci_memory.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

loci_memory-0.0.2/src/loci_memory.egg-info/requires.txt

@@ -0,0 +1,3 @@
+chromadb>=1.0.16
+fastmcp>=3.2.3
+typing-extensions>=4.13.1

loci_memory-0.0.2/src/loci_memory.egg-info/top_level.txt

@@ -0,0 +1 @@
+loci-memory