modaic 0.1.0__py3-none-any.whl

modaic/types.py

@@ -0,0 +1,287 @@
+from typing import Any, List, Literal, Optional, Tuple, Type, get_origin
+
+from pydantic import (
+    BaseModel,
+    RootModel,
+    WithJsonSchema,
+    field_validator,
+    model_validator,
+)
+from pydantic import (
+    Field as PydanticField,
+)
+from pydantic.fields import FieldInfo
+from pydantic_core import PydanticUndefined
+from typing_extensions import Annotated
+
+from .exceptions import SchemaError
+
+int8 = Annotated[
+    int,
+    PydanticField(ge=-128, le=127),
+    WithJsonSchema({"type": "integer", "format": "int8"}),
+]
+int16 = Annotated[
+    int,
+    PydanticField(ge=-32768, le=32767),
+    WithJsonSchema({"type": "integer", "format": "int16"}),
+]
+int32 = Annotated[
+    int,
+    PydanticField(ge=-(2**31), le=2**31 - 1),
+    WithJsonSchema({"type": "integer", "format": "int32"}),
+]
+int64 = Annotated[
+    int,
+    PydanticField(ge=-(2**63), le=2**63 - 1),
+    WithJsonSchema({"type": "integer", "format": "int64"}),
+]
+double = Annotated[
+    float,
+    PydanticField(ge=-1.87e308, le=1.87e308),
+    WithJsonSchema({"type": "number", "format": "double"}),
+]
+
+
+class ArrayMeta(type):
+    def __getitem__(cls, params: type | tuple[type, int]):
+        if isinstance(params, tuple) and len(params) == 2:
+            dtype = params[0]
+            max_size = params[1]
+        elif isinstance(params, type) or get_origin(params) is Annotated:
+            dtype = params
+            max_size = None
+        else:
+            raise TypeError(
+                f"{cls.__name__} requires either 2 parameters: {cls.__name__}[dtype, max_size] or 1 parameter: {cls.__name__}[dtype]"
+            )
+
+        assert isinstance(dtype, type) or get_origin(dtype) is Annotated, f"dtype must be a type, got {dtype}"
+        assert max_size is None or (isinstance(max_size, int) and max_size > 0), (
+            f"max_size must be an int or None, got {max_size}"
+        )
+
+        return Annotated[
+            List[dtype],
+            PydanticField(min_length=0, max_length=max_size),
+        ]
+
+
+class Array(List, metaclass=ArrayMeta):
+    """
+    Array field type for `Context`. Must be created with Array[dtype, max_size]
+
+    Args:
+        dtype (Type): The type of the elements in the array.
+        max_size (int): The maximum size of the array.
+
+    Example:
+        A `Email` context class that stores an email's content and recipients.
+        ```python
+        from modaic.types import Array
+        from modaic.context import Context
+
+        class Email(Context):
+            content: str
+            recipients: Array[str, 100]
+        ```
+    """
+
+    pass
+
+
+class StringMeta(type):
+    def __getitem__(cls, params: int):
+        if not isinstance(params, int):
+            raise TypeError(f"{cls.__name__} requires exactly 1 parameters: {cls.__name__}[max_size]")
+
+        max_size = params
+        if not isinstance(max_size, int) or max_size <= 1:
+            raise TypeError(f"Max size must be a >= 1, got {max_size}")
+
+        return Annotated[
+            str,
+            PydanticField(max_length=max_size),
+            WithJsonSchema({"type": "string", "maxLength": max_size}),
+        ]
+
+
+class String(str, metaclass=StringMeta):
+    """String type that can be parameterized with max_length constraint.
+
+    Args:
+        max_size (int): The maximum length of the string.
+
+    Example:
+        ```python
+        from modaic.types import String
+        from modaic.context import Context
+
+        class Email(Context):
+            subject: String[100]
+            content: str
+            recipients: Array[str, 100]
+        ```
+    """
+
+    pass
+
+
+def fetch_type(metadata: list, type_class: Type) -> Optional[Type]:
+    return next((x for x in metadata if isinstance(x, type_class)), None)
+
+
+def get_original_class(field_info: FieldInfo, default: Optional[Type] = None) -> Type:
+    if json_schema_extra := getattr(field_info, "json_schema_extra", None):
+        return json_schema_extra.get("original_class", default)
+    return default
+
+
+int_format = Literal["int8", "int16", "int32", "int64"]
+float_format = Literal["float", "double"]
+
+
+class SchemaField(BaseModel):
+    optional: bool
+    type: Literal["array", "integer", "number", "object", "string", "boolean"]
+    format: int_format | float_format | None
+    size: Optional[int]
+    inner_type: Optional["InnerField"]
+    is_id: bool = False
+    is_unique: bool = False
+
+    @model_validator(mode="after")
+    def validate_field(self) -> "SchemaField":
+        if self.type == "array" and self.inner_type is None:
+            raise SchemaError("Array type must have an inner type")
+        if self.is_id and not self.is_unique:
+            raise SchemaError("id field must be unique")
+        if self.is_id and self.optional:
+            raise SchemaError("id field cannot be optional")
+        if self.is_id and self.type != "string":
+            raise SchemaError("id field must be a string")
+        # NOTE: handle case where the float type was used and therefore not annotated with a format
+        if self.type == "number":
+            self.format = self.format or "float"
+        return self
+
+    @staticmethod
+    def from_json_schema_property(
+        field_schema: dict, is_id: bool = False, is_unique: Optional[bool] = None
+    ) -> "SchemaField":
+        inspected_type, is_optional = _inspect_type(field_schema)
+        if "maxItems" in inspected_type and "maxLength" in inspected_type:
+            raise SchemaError("maxItems and maxLength cannot both be present in a schema field")
+        if "items" in inspected_type:
+            inner_type = InnerField.from_json_schema_property(inspected_type["items"])
+        else:
+            inner_type = None
+        if is_unique is None:
+            is_unique = is_id
+
+        return SchemaField(
+            optional=is_optional,
+            type=inspected_type["type"],
+            format=inspected_type.get("format", None),
+            size=inspected_type.get("maxItems", None) or inspected_type.get("maxLength", None),
+            inner_type=inner_type,
+            is_id=is_id,
+            is_unique=is_unique,
+        )
+
+
+class InnerField(BaseModel):
+    type: Literal["integer", "number", "string", "boolean"]
+    format: int_format | float_format | None = None
+    size: Optional[int] = None
+
+    @model_validator(mode="after")
+    def validate_field(self) -> "InnerField":
+        if self.type == "number":
+            self.format = self.format or "float"
+        return self
+
+    @staticmethod
+    def from_json_schema_property(inner_schema: dict) -> "InnerField":
+        inspected_type, is_optional = _inspect_type(inner_schema)
+        # NOTE: handle case where the float type was used and therefore not annotated with a format
+        if is_optional:
+            raise SchemaError("Array/List elements cannot be None/null")
+        return InnerField(
+            type=inspected_type["type"],
+            format=inspected_type.get("format", None),
+            size=inspected_type.get("size", None),
+        )
+
+
+class Schema(RootModel[dict[str, SchemaField]]):
+    @field_validator("root")
+    @classmethod
+    def validate_is_id(cls, v: dict[str, SchemaField]) -> dict[str, SchemaField]:
+        offenders = [k for k, sf in v.items() if sf.is_id and k != "id"]
+        if offenders:
+            raise SchemaError(
+                "is_id can only be True for the key 'id'; offending keys: " + ", ".join(repr(k) for k in offenders)
+            )
+        return v
+
+    @staticmethod
+    def from_json_schema(schema: dict) -> "Schema":
+        """
+        Converts an OpenAPI JSON schema to a Modaic schema that can be used with modaic databases.
+        Warnings:
+            Not designed to handle all edge cases of OpenAPI schemas. Only designed to work with jsons output by pydantics BaseModel model_json_schema()
+        """
+        validated_fields = {}
+        for field_name, field_schema in schema["properties"].items():
+            schema_field = SchemaField.from_json_schema_property(field_schema, is_id=field_name == "id")
+            validated_fields[field_name] = schema_field
+        return Schema(validated_fields)
+
+    def as_dict(self) -> dict[str, SchemaField]:
+        return self.root
+
+
+def _inspect_type(field_schema: dict) -> Tuple[dict, bool]:
+    """
+    This function inspects the json schema ensuring it is a valid modaic schema. Returns from this function are guaranteed to:
+    1. Be a dictionary containing the key "type"
+    2. Not have unions other than a single union with null
+    3. All {"$ref": "..."} is replaced with {"type": "object"}
+    Returns:
+        Tuple[dict, bool]: the dict containing the type, and a boolean indicating if the field is optional
+    """
+    if anyOf := field_schema.get("anyOf", None):  # noqa: N806
+        if len(anyOf) > 2 or not any(_is_null(item) for item in anyOf):
+            raise SchemaError("Unions are not supported for Modaic Schemas")
+        elif any(not _is_null(type_ := item) for item in anyOf):
+            return _handle_if_ref(type_), True
+        else:
+            raise SchemaError("Invalid field schema")
+    elif "type" in field_schema:
+        return _handle_if_ref(field_schema), False
+    elif "$ref" in field_schema:
+        return {"type": "object"}, False
+    else:
+        raise SchemaError("Invalid field schema")
+
+
+def _handle_if_ref(field_schema: dict) -> dict:
+    """
+    Handles the case where the field is a reference to another schema. Returns an {"type": "object"}
+    """
+    if "$ref" in field_schema:
+        return {"type": "object"}
+    else:
+        return field_schema
+
+
+def _is_null(field_schema: dict) -> bool:
+    return field_schema.get("type", "") == "null"
+
+
+def Field(default: Any = PydanticUndefined, *, hidden: bool = False, **kwargs) -> FieldInfo:  # noqa: N802, ANN001
+    if hidden:
+        return PydanticField(default=default, **kwargs, json_schema_extra={"hidden": True})
+    else:
+        return PydanticField(default=default, **kwargs)

modaic/utils.py

@@ -0,0 +1,21 @@
+import os
+import re
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+def compute_cache_dir() -> Path:
+    """Return the cache directory used to stage internal modules."""
+    cache_dir_env = os.getenv("MODAIC_CACHE")
+    default_cache_dir = Path(os.path.expanduser("~")) / ".cache" / "modaic"
+    cache_dir = Path(cache_dir_env).expanduser().resolve() if cache_dir_env else default_cache_dir.resolve()
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    return cache_dir
+
+
+def validate_project_name(text: str) -> bool:
+    """Letters, numbers, underscore, hyphen"""
+    assert bool(re.match(r'^[a-zA-Z0-9_]+$', text)), "Invalid project name. Must contain only letters, numbers, and underscore."

modaic-0.1.0.dist-info/METADATA

@@ -0,0 +1,281 @@
+Metadata-Version: 2.4
+Name: modaic
+Version: 0.1.0
+Summary: **Mod**ular **A**gent **I**nfrastructure **C**ollective, a python framework for managing and sharing DSPy agents
+Author-email: Tyrin <tytodd@mit.edu>, Farouk <farouk@modaic.dev>
+License: MIT License
+        
+        Copyright (c) 2025 Modaic Inc
+        
+        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.
+        
+        ---
+        
+        Additional Terms:
+        
+        1. You may not modify this Software in any way that changes the default hub
+           endpoint, nor distribute derivative works that route agents or models to
+           a hub other than modaic.dev.
+        
+        2. All other rights are granted as per the MIT License.
+        
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aenum>=3.1.16
+Requires-Dist: dspy>=2.6.27
+Requires-Dist: duckdb>=1.3.2
+Requires-Dist: filetype>=1.2.0
+Requires-Dist: gitpython>=3.1.45
+Requires-Dist: immutables>=0.21
+Requires-Dist: langchain-community>=0.3.29
+Requires-Dist: langchain-core>=0.3.72
+Requires-Dist: langchain-text-splitters>=0.3.9
+Requires-Dist: more-itertools>=10.8.0
+Requires-Dist: opik>=1.8.42
+Requires-Dist: pillow>=11.3.0
+Requires-Dist: pymilvus>=2.5.14
+Requires-Dist: sqlalchemy>=2.0.42
+Requires-Dist: tomlkit>=0.13.3
+Provides-Extra: pinecone
+Requires-Dist: pinecone>=7.3.0; extra == "pinecone"
+Dynamic: license-file
+
+[![Docs](https://img.shields.io/badge/docs-available-brightgreen.svg)](https://docs.modaic.dev)
+# Modaic 🐙
+**Mod**ular **A**gent **I**nfrastructure **C**ollective, a Python framework for building AI agents with structured context management, database integration, and retrieval-augmented generation (RAG) capabilities.
+
+## Overview
+
+Modaic provides a comprehensive toolkit for creating intelligent agents that can work with diverse data sources including tables, documents, and databases. Built on top of DSPy, it offers a way to share and manage declarative agent architectures with integrated vector, SQL, and graph database support.
+
+## Key Features
+
+- **Hub Support**: Load and share precompiled agents from Modaic Hub
+- **Context Management**: Structured handling of molecular and atomic context types
+- **Database Integration**: Support for Vector (Milvus, Pinecone, Qdrant), SQL (SQLite, MySQL, PostgreSQL), and Graph (Memgraph, Neo4j)
+- **Agent Framework**: Precompiled and auto-loading agent architectures
+- **Table Processing**: Advanced Excel/CSV processing with SQL querying capabilities
+
+
+## Installation
+
+### Using uv (recommended)
+
+```bash
+uv add modaic
+```
+
+Optional (for hub operations):
+
+```bash
+export MODAIC_TOKEN="<your-token>"
+```
+
+### Using pip
+Please note that you will not be able to push agents to the Modaic Hub with pip.
+```bash
+pip install modaic
+```
+## Quick Start
+
+### Creating a Simple Agent
+
+```python
+from modaic import PrecompiledAgent, PrecompiledConfig
+
+class WeatherConfig(PrecompiledConfig):
+    weather: str = "sunny"
+
+class WeatherAgent(PrecompiledAgent):
+    config: WeatherConfig
+
+    def __init__(self, config: WeatherConfig, **kwargs):
+        super().__init__(config, **kwargs)
+
+    def forward(self, query: str) -> str:
+        return f"The weather in {query} is {self.config.weather}."
+
+agent = WeatherAgent(WeatherConfig())
+print(agent(query="Tokyo"))
+```
+
+Save and load locally:
+
+```python
+agent.save_precompiled("./my-weather")
+
+from modaic import AutoAgent, AutoConfig
+
+cfg = AutoConfig.from_precompiled("./my-weather", local=True)
+loaded = AutoAgent.from_precompiled("./my-weather", local=True)
+print(loaded(query="Kyoto"))
+```
+
+### Working with Tables
+
+```python
+from pathlib import Path
+from modaic.context import Table, TableFile
+import pandas as pd
+
+# Load from Excel/CSV
+excel = TableFile.from_file(
+    file_ref="employees.xlsx",
+    file=Path("employees.xlsx"),
+    file_type="xlsx",
+)
+csv = TableFile.from_file(
+    file_ref="data.csv",
+    file=Path("data.csv"),
+    file_type="csv",
+)
+
+# Create from DataFrame
+df = pd.DataFrame({"col1": [1, 2, 3], "col2": [4, 5, 6]})
+table = Table(df=df, name="my_table")
+
+# Query with SQL (refer to in-memory table as `this`)
+result = table.query("SELECT * FROM this WHERE col1 > 1")
+
+# Convert to markdown
+markdown = table.markdown()
+```
+
+### Database Integration
+
+#### SQL Database
+```python
+from modaic.databases import SQLDatabase, SQLiteBackend
+
+# Configure and connect
+backend = SQLiteBackend(db_path="my_database.db")
+db = SQLDatabase(backend)
+
+# Add table
+db.add_table(table)
+
+# Query
+rows = db.fetchall("SELECT * FROM my_table")
+```
+
+#### Vector Database
+#### Graph Database
+```python
+from modaic.context import Context, Relation
+from modaic.databases import GraphDatabase, MemgraphConfig, Neo4jConfig
+
+# Configure backend (choose one)
+mg = GraphDatabase(MemgraphConfig())
+# or
+neo = GraphDatabase(Neo4jConfig())
+
+# Define nodes
+class Person(Context):
+    name: str
+    age: int
+
+class KNOWS(Relation):
+    since: int
+
+alice = Person(name="Alice", age=30)
+bob = Person(name="Bob", age=28)
+
+# Save nodes
+alice.save(mg)
+bob.save(mg)
+
+# Create relationship (Alice)-[KNOWS]->(Bob)
+rel = (alice >> KNOWS(since=2020) >> bob)
+rel.save(mg)
+
+# Query
+rows = mg.execute_and_fetch("MATCH (a:Person)-[r:KNOWS]->(b:Person) RETURN a, r, b LIMIT 5")
+```
+```python
+from modaic import Embedder
+from modaic.context import Text
+from modaic.databases import VectorDatabase, MilvusBackend
+
+# Setup embedder and backend
+embedder = Embedder("openai/text-embedding-3-small")
+backend = MilvusBackend.from_local("vector.db")  # milvus lite
+
+# Initialize database
+vdb = VectorDatabase(backend=backend, embedder=embedder, payload_class=Text)
+
+# Create collection and add records
+vdb.create_collection("my_collection", payload_class=Text)
+vdb.add_records("my_collection", [Text(text="hello world"), Text(text="modaic makes sharing agents easy")])
+
+# Search
+results = vdb.search("my_collection", query="hello", k=3)
+top_hit_text = results[0][0].context.text
+```
+
+## Architecture
+### Agent Types
+
+1. **PrecompiledAgent**: Statically defined agents with explicit configuration
+2. **AutoAgent**: Dynamically loaded agents from Modaic Hub or local repositories
+
+### Database Support
+
+| Database Type | Providers | Use Case |
+|---------------|-----------|----------|
+| **Vector** | Milvus | Semantic search, RAG |
+| **SQL** | SQLite, MySQL, PostgreSQL | Structured queries, table storage |
+
+## Examples
+
+### TableRAG Example
+
+The TableRAG example demonstrates a complete RAG pipeline for table-based question answering:
+
+```python
+from modaic.precompiled_agent import PrecompiledConfig, PrecompiledAgent
+from modaic.context import Table
+from modaic.databases import VectorDatabase, SQLDatabase
+from modaic.types import Indexer
+
+class TableRAGConfig(PrecompiledConfig):
+    agent_type = "TableRAGAgent"
+    k_recall: int = 50
+    k_rerank: int = 5
+
+class TableRAGAgent(PrecompiledAgent):
+    config: TableRAGConfig # ! Important: config must be annotated with the config class
+    
+    def __init__(self, config: TableRAGConfig, indexer: Indexer, **kwargs):
+        super().__init__(config, **kwargs)
+        self.indexer = indexer
+        # Initialize DSPy modules for reasoning
+    
+    def forward(self, user_query: str) -> str:
+        # Retrieve relevant tables
+        # Generate SQL queries
+        # Combine results and provide answer
+        pass
+```
+
+## Support
+
+For issues and questions:
+- GitHub Issues: `https://github.com/modaic-ai/modaic/issues`
+- Docs: `https://docs.modaic.dev`

modaic-0.1.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+modaic/__init__.py,sha256=rf2O0S7OAz5fBkmOcwygsM3u8Nmq_ios01ToNweNnSk,639
+modaic/auto_agent.py,sha256=jegs8HMbE5OICZIDtBrP4kIma_R7rzy-1Kgmb_-eCck,8695
+modaic/exceptions.py,sha256=XxzxOWjZTzT3l1BqTr7coJnVGxJq53uppRNrqP__YGo,651
+modaic/hub.py,sha256=iWvWjaZxurd2BRXTS2gjhBvqVE1TDtwF0N7Falwj04Q,10527
+modaic/indexing.py,sha256=L0O5yV7AhDUJ0gMyGE17BvHN2gwHxwkOMaxNTkyWQ8g,4185
+modaic/module_utils.py,sha256=DDXUmcGFdaah_EhTlfdHC26ohmMwLNlIYo6PzYzKzqc,10728
+modaic/observability.py,sha256=QEjLbmsVQzWZuxKQU8TBMSHsHVGvTzOeoNlEn_srmyg,9955
+modaic/precompiled.py,sha256=g0AsFrHxzTlDETDqxZFqjHaLqW6m5OpGGyI01xDBT5U,15788
+modaic/query_language.py,sha256=c-La7jYhHgNyjlQaxz0ALvUoiCDGzH9DpSD_9cozxNQ,10463
+modaic/types.py,sha256=sHJ7J9YGfWIkDPfCuRc-n4O9n7g7LNnKSZperAviRFc,9905
+modaic/utils.py,sha256=zbeMlrP_hoo8JUKR_bcuYPxrlYcckY3p0KJ_h4CN5VQ,721
+modaic/agents/rag_agent.py,sha256=f8s3EILOPUxMpOKDoAvk-cfLE8S9kFNvkEcAC5z2EmQ,798
+modaic/agents/registry.py,sha256=z6GuPxGrq2dinCamiMJ_HVPsD9Tp9XWDUSMZ-uhWPrU,2446
+modaic/context/__init__.py,sha256=WTBo-WqhgeR84P3MEq0snLZyIHnLyv9VYO5Wfp4vrZo,534
+modaic/context/base.py,sha256=QrRNBs05fb5EXN4intHT4D-XIG76RzvrO6j8RXJpzd4,40380
+modaic/context/dtype_mapping.py,sha256=xRasW-H92YEuOfH8SbsVnodM9F-90pazott8qF2GWHw,519
+modaic/context/table.py,sha256=c0OUVwglaDRtJ2Uo9z7bAKhIJpJXqwWk1VkKwQNOvUY,17696
+modaic/context/text.py,sha256=S8E-dbTe-Wip8KCZ5vcIOZVyiVQReIL4bSo0anQw828,2581
+modaic/databases/__init__.py,sha256=-w_yiY-Sqi1SgcPD5oAQL7MU4VXTihPa1GYGlrHfsFw,784
+modaic/databases/graph_database.py,sha256=vMCYQrnBu5AIIGF_akkU9lWKFdbIDF3tlcyxiNQ_vSQ,9933
+modaic/databases/sql_database.py,sha256=wqy7AqsalhmYsbNPy0FCAg1FrUKN6Bd8ytwyJireC94,12057
+modaic/databases/vector_database/__init__.py,sha256=sN1SuSAMC9NHJDOa80BN_olccaHgmiW2Ek57hBvdZWo,306
+modaic/databases/vector_database/vector_database.py,sha256=RsuRemgFV06opY26CekqLLRoAEFYOGl_CMuFETrYS0c,25238
+modaic/databases/vector_database/benchmarks/baseline.py,sha256=ZhiYzHnizsLesAIQA93RhWaaYxEZp6ygExmnBhU9Dio,5209
+modaic/databases/vector_database/benchmarks/common.py,sha256=fgPfnv1P55YAB5S6mORIpDMtKymsCPBjuQNiO5qLbJQ,1386
+modaic/databases/vector_database/benchmarks/fork.py,sha256=Q-2dnsxB4_28mfkGHS2Y9-f-Fksym1bbdTFP-r0AKTk,5566
+modaic/databases/vector_database/benchmarks/threaded.py,sha256=s2s1GwIRYq9oon5nsF_DRa65leCYc5uws6a5oHijk1M,5195
+modaic/databases/vector_database/vendors/milvus.py,sha256=YT6rhRhe4bEC3lsgddno8k6wi1HqawqhvXXVkNYs3pY,15732
+modaic/databases/vector_database/vendors/mongodb.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+modaic/databases/vector_database/vendors/pinecone.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+modaic/databases/vector_database/vendors/qdrant.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+modaic/storage/__init__.py,sha256=Zs-Y_9jfYUE8XVp8z-El0ZXFM_ZVMqM9aQ6fgGPZsf8,131
+modaic/storage/file_store.py,sha256=kSS7gTP_-16wR3Xgq3frF1BZ8Dw8N--kG4V9rrCXPcc,7315
+modaic/storage/pickle_store.py,sha256=fu9jkmmKNE852Y4R1NhOFePLfd2gskhHSXxuq1G1S3I,778
+modaic-0.1.0.dist-info/licenses/LICENSE,sha256=7LMx9j453Vz1DoQbFot8Uhp9SExF5wlOx7c8vw2qhsE,1333
+modaic-0.1.0.dist-info/METADATA,sha256=9Q1xSwbRGQl6GKKm32POVFdBlprvBCCcKxtNsVMKFFM,8585
+modaic-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+modaic-0.1.0.dist-info/top_level.txt,sha256=RXWGuF-TsW8-17DveTJMPRiAgg_Rf2mq5F3R7tNu6t8,7
+modaic-0.1.0.dist-info/RECORD,,

modaic-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

modaic-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,31 @@
+MIT License
+
+Copyright (c) 2025 Modaic Inc
+
+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.
+
+---
+
+Additional Terms:
+
+1. You may not modify this Software in any way that changes the default hub
+   endpoint, nor distribute derivative works that route agents or models to
+   a hub other than modaic.dev.
+
+2. All other rights are granted as per the MIT License.

modaic-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+modaic