memorizz 0.0.1__py3-none-any.whl

memorizz/__init__.py

@@ -0,0 +1,6 @@
+print("Starting memorizz __init__.py")
+from .database.mongodb import MongoDBTools, MongoDBToolsConfig, get_embedding, get_mongodb_toolbox
+print("Finished importing from mongodb in memorizz __init__.py")
+
+__all__ = ['MongoDBTools', 'MongoDBToolsConfig', 'get_embedding', 'get_mongodb_toolbox']
+print("Exiting memorizz __init__.py")

memorizz/database/__init__.py

@@ -0,0 +1,5 @@
+print("Entering database __init__.py")
+from .mongodb import MongoDBTools, MongoDBToolsConfig, get_embedding, get_mongodb_toolbox
+
+__all__ = ['MongoDBTools', 'MongoDBToolsConfig', 'get_embedding', 'get_mongodb_toolbox']
+print("Exiting database __init__.py")

memorizz/database/mongodb/__init__.py

@@ -0,0 +1,5 @@
+print("Entering mongodb __init__.py")
+from .mongodb_tools import MongoDBTools, MongoDBToolsConfig, get_embedding, get_mongodb_toolbox
+
+__all__ = ['MongoDBTools', 'MongoDBToolsConfig', 'get_embedding', 'get_mongodb_toolbox']
+print("Exiting mongodb __init__.py")

memorizz/database/mongodb/mongodb_tools.py

@@ -0,0 +1,166 @@
+import os
+import json
+import getpass
+import inspect
+from functools import wraps
+from typing import get_type_hints, List, Dict, Any, Optional
+import openai
+import pymongo
+import logging
+from dataclasses import dataclass
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+@dataclass
+class MongoDBToolsConfig:
+    mongo_uri: Optional[str] = None
+    db_name: str = 'function_calling_db'
+    collection_name: str = 'tools'
+    embedding_model: str = "text-embedding-3-small"
+    vector_search_candidates: int = 150
+    vector_index_name: str = "vector_index"
+
+def get_embedding(text: str, model: str = "text-embedding-3-small") -> List[float]:
+    text = text.replace("\n", " ")
+    try:
+        return openai.OpenAI().embeddings.create(input=[text], model=model).data[0].embedding
+    except Exception as e:
+        logger.error(f"Error generating embedding: {str(e)}")
+        raise
+
+class MongoDBTools:
+    def __init__(self, config: MongoDBToolsConfig = MongoDBToolsConfig()):
+        self.config = config
+        if self.config.mongo_uri is None:
+            self.config.mongo_uri = os.getenv('MONGO_URI') or getpass.getpass("Enter MongoDB URI: ")
+        try:
+            self.mongo_client = pymongo.MongoClient(self.config.mongo_uri)
+            self.db = self.mongo_client[self.config.db_name]
+            self.tools_collection = self.db[self.config.collection_name]
+        except Exception as e:
+            logger.error(f"Error connecting to MongoDB: {str(e)}")
+            raise
+
+    def mongodb_toolbox(self, collection: Optional[pymongo.collection.Collection] = None):
+        if collection is None:
+            collection = self.tools_collection
+
+        def decorator(func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+
+            signature = inspect.signature(func)
+            docstring = inspect.getdoc(func) or ""
+
+            if not docstring:
+                raise ValueError(f"Error registering tool {func.__name__}: Docstring is missing. Please provide a docstring for the function.")
+
+            type_hints = get_type_hints(func)
+
+            tool_def = {
+                "name": func.__name__,
+                "description": docstring.strip(),
+                "parameters": {
+                    "type": "object",
+                    "properties": {},
+                    "required": []
+                }
+            }
+
+            for param_name, param in signature.parameters.items():
+                if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                    continue
+
+                param_type = type_hints.get(param_name, type(None))
+                json_type = "string"
+                if param_type in (int, float):
+                    json_type = "number"
+                elif param_type == bool:
+                    json_type = "boolean"
+
+                tool_def["parameters"]["properties"][param_name] = {
+                    "type": json_type,
+                    "description": f"Parameter {param_name}"
+                }
+
+                if param.default == inspect.Parameter.empty:
+                    tool_def["parameters"]["required"].append(param_name)
+
+            tool_def["parameters"]["additionalProperties"] = False
+
+            try:
+                vector = get_embedding(tool_def["description"], self.config.embedding_model)
+                tool_doc = {
+                    **tool_def,
+                    "embedding": vector
+                }
+                collection.update_one({"name": func.__name__}, {"$set": tool_doc}, upsert=True)
+                logger.info(f"Successfully registered tool: {func.__name__}")
+            except Exception as e:
+                logger.error(f"Error registering tool {func.__name__}: {str(e)}")
+                raise
+
+            return wrapper
+        return decorator
+
+    def _vector_search(self, user_query: str, collection: Optional[pymongo.collection.Collection] = None, limit: int = 2) -> List[Dict[str, Any]]:
+        if collection is None:
+            collection = self.tools_collection
+
+        try:
+            query_embedding = get_embedding(user_query, self.config.embedding_model)
+        except Exception as e:
+            logger.error(f"Error generating embedding for query: {str(e)}")
+            raise
+
+        vector_search_stage = {
+            "$vectorSearch": {
+                "index": self.config.vector_index_name,
+                "queryVector": query_embedding,
+                "path": "embedding",
+                "numCandidates": self.config.vector_search_candidates,
+                "limit": limit
+            }
+        }
+
+        unset_stage = {
+            "$unset": "embedding"
+        }
+
+        pipeline = [vector_search_stage, unset_stage]
+
+        try:
+            results = collection.aggregate(pipeline)
+            return list(results)
+        except Exception as e:
+            logger.error(f"Error performing vector search: {str(e)}")
+            raise
+
+    def populate_tools(self, user_query: str, num_tools: int = 2) -> List[Dict[str, Any]]:
+        try:
+            search_results = self._vector_search(user_query, limit=num_tools)
+            tools = []
+            for result in search_results:
+                print(result)
+                tool = {
+                    "type": "function",
+                    "function": {
+                        "name": result["name"],
+                        "description": result["description"],
+                        "parameters": result["parameters"]
+                    }
+                }
+                tools.append(tool)
+            logger.info(f"Successfully populated {len(tools)} tools")
+            return tools
+        except Exception as e:
+            logger.error(f"Error populating tools: {str(e)}")
+            raise
+
+__all__ = ['MongoDBTools', 'MongoDBToolsConfig', 'get_embedding']
+
+# You can create a function to get the mongodb_toolbox decorator:
+def get_mongodb_toolbox(config: MongoDBToolsConfig = MongoDBToolsConfig()):
+    return MongoDBTools(config).mongodb_toolbox

memorizz-0.0.1.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.3
+Name: memorizz
+Version: 0.0.1
+Summary: A memory management library for Python
+Project-URL: Homepage, https://github.com/RichmondAlake/memorizz
+Project-URL: Bug Tracker, https://github.com/yourusername/memorizz/issues
+Author-email: Richmond Alake <richmond.alake@gmail.com>
+License-File: LICENCE.txt
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+MemoRizz is a comprehensive library for AI-assisted tools and functionalities. It currently includes MongoDB tools for storing function definitions and performing customizable vector searches.
+
+## Installation
+
+```
+pip install memorizz
+```
+
+## Usage
+
+MemoRizz can be used with either a custom configuration or the default settings. Here are examples of both approaches:
+
+### Using Custom Configuration
+
+```python
+from memorizz.databases.mongodb import MongoDBTools, MongoDBToolsConfig, mongodb_toolbox
+
+# Create a custom configuration
+custom_config = MongoDBToolsConfig(
+    mongo_uri="mongodb://custom-uri:27017",
+    db_name="my_custom_db",
+    collection_name="my_custom_tools",
+    embedding_model="text-embedding-ada-002",
+    vector_search_candidates=200,
+    vector_index_name="my_custom_index"
+)
+
+# Initialize MongoDBTools with custom configuration
+custom_mongo_tools = MongoDBTools(custom_config)
+
+# Use the custom mongodb_toolbox decorator
+@custom_mongo_tools.mongodb_toolbox()
+def custom_function(param1: str, param2: int) -> str:
+    """
+    This is a custom function using a custom configuration.
+    """
+    return f"Custom processed {param1} with {param2}"
+
+# Use the custom tools
+user_query = "How do I process something custom?"
+custom_tools = custom_mongo_tools.populate_tools(user_query, num_tools=3)
+
+print("Custom tools:", custom_tools)
+```
+
+### Using Default Configuration
+
+```python
+from memorizz.databases.mongodb import mongodb_toolbox, MongoDBTools
+
+# Use the default mongodb_toolbox decorator
+@mongodb_toolbox()
+def default_function(param1: str, param2: int) -> str:
+    """
+    This is a default function using the default configuration.
+    """
+    return f"Default processed {param1} with {param2}"
+
+# Use the default tools
+default_mongo_tools = MongoDBTools()  # This uses the default configuration
+user_query = "How do I process something with default settings?"
+default_tools = default_mongo_tools.populate_tools(user_query, num_tools=2)
+
+print("Default tools:", default_tools)
+```
+
+In both cases, the `mongodb_toolbox` decorator is used to register functions, and the `populate_tools` method is used to retrieve relevant tools based on a user query. The main difference is in the setup and configuration.
+
+The custom configuration approach allows you to specify your own MongoDB URI, database name, collection name, and other settings. This is useful when you need to connect to a specific MongoDB instance or customize the behavior of the tools.
+
+The default configuration approach is simpler and requires less setup. It's suitable for quick starts or when the default settings meet your needs.
+
+Choose the approach that best fits your project requirements and structure.
+
+## Features
+
+- MongoDB Tools:
+  - Automatic tool registration with MongoDB
+  - Vector search based on user queries
+  - Customizable number of tools returned
+  - Configurable embedding model and search parameters
+  - Error handling and logging
+- Extensible structure for future database support
+
+
+## Feature Roadmap
+
+- [x] Implement basic MongoDB tools functionality
+- [x] Add customizable vector search
+- [x] Implement error handling and logging
+- [x] Create PyPI package
+- [x] Restructure package for extensibility to other databases
+- [ ] Add support for multiple embedding models to make MongoDBToolsConfig embedding model agnostic
+- [ ] Implement MemScore logic for improved tool ranking and memory component retrival
+- [ ] Add async support for improved performance
+- [ ] Implement caching mechanism for embeddings and search results
+- [ ] Create comprehensive API documentation
+- [ ] Implement automated testing suite with high coverage
+- [ ] Create example projects and use cases
+- [ ] Add support for additional databases (e.g., PostgreSQL, Redis)
+
+## License
+
+This project is licensed under the MIT License.

memorizz-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+memorizz/__init__.py,sha256=FxpzM-4NJ0PdO5r8rE-a1eT3hUCDapCNDcU9rWX-Ow0,330
+memorizz/database/__init__.py,sha256=tApVKs5G8WB-mCl7qEOWrFqgLxMFuxtWlD-HRkLVqX8,256
+memorizz/database/mongodb/__init__.py,sha256=zszN974hb2ejKuCMou0GKayhzglb5FSI_sb0sL72U5I,260
+memorizz/database/mongodb/mongodb_tools.py,sha256=jkx1DtIJk-ZBEw-QUN0OvVeVEZIZirwXkUFnrngnaj8,6110
+memorizz-0.0.1.dist-info/METADATA,sha256=-LibnPjLChsMYwS5mT7mAMtcXDUW7czNSHqiv5qlOS8,4356
+memorizz-0.0.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+memorizz-0.0.1.dist-info/licenses/LICENCE.txt,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+memorizz-0.0.1.dist-info/RECORD,,

memorizz-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.25.0
+Root-Is-Purelib: true
+Tag: py3-none-any