mcal-ai 0.1.0__py3-none-any.whl

mcal/providers/bedrock.py

@@ -0,0 +1,217 @@
+"""
+AWS Bedrock LLM Provider for MCAL.
+"""
+
+import json
+import asyncio
+import logging
+from typing import Dict, List, Any, Optional
+import boto3
+from botocore.exceptions import ClientError
+
+from ..core.retry import (
+    llm_retry,
+    classify_boto_error,
+    LLMThrottlingError,
+    LLMServerError,
+    LLMTimeoutError,
+)
+from ..core.rate_limiter import (
+    TokenBucketRateLimiter,
+    RateLimitConfig,
+    create_rate_limiter,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class BedrockProvider:
+    """AWS Bedrock LLM provider for MCAL."""
+    
+    MODELS = {
+        # Fast models (simple tasks: intent detection, graph updates)
+        # Use cross-region inference profile IDs for on-demand throughput
+        "llama-3.1-8b": {"id": "us.meta.llama3-1-8b-instruct-v1:0", "max_tokens": 4096, "type": "llama", "tier": "fast"},
+        "llama-3.2-3b": {"id": "us.meta.llama3-2-3b-instruct-v1:0", "max_tokens": 4096, "type": "llama", "tier": "fast"},
+        # Smart models (complex tasks: decision extraction, reasoning)
+        "llama-3.3-70b": {"id": "us.meta.llama3-3-70b-instruct-v1:0", "max_tokens": 4096, "type": "llama", "tier": "smart"},
+        "llama-4-maverick": {"id": "us.meta.llama4-maverick-17b-instruct-v1:0", "max_tokens": 4096, "type": "llama", "tier": "smart"},
+        "llama-3.1-70b": {"id": "us.meta.llama3-1-70b-instruct-v1:0", "max_tokens": 4096, "type": "llama", "tier": "smart"},
+    }
+    
+    # Default models for tiered selection
+    DEFAULT_FAST_MODEL = "llama-3.1-8b"
+    DEFAULT_SMART_MODEL = "llama-3.3-70b"
+    
+    def __init__(
+        self,
+        model: str = "llama-3.3-70b",
+        region: str = "us-east-1",
+        temperature: float = 0.7,
+        max_tokens: int = 2048,
+        # Rate limiting options (Issue #39)
+        enable_rate_limiting: bool = False,
+        rate_limit_rpm: int = 60,
+        rate_limit_tpm: int = 100_000,
+        max_cost_per_hour: Optional[float] = None,
+        enable_cost_logging: bool = True,
+    ):
+        """
+        Initialize Bedrock provider.
+        
+        Args:
+            model: Model name (e.g., "llama-3.3-70b")
+            region: AWS region
+            temperature: Sampling temperature
+            max_tokens: Maximum tokens per response
+            enable_rate_limiting: Enable rate limiting (default: False)
+            rate_limit_rpm: Requests per minute limit (default: 60)
+            rate_limit_tpm: Tokens per minute limit (default: 100,000)
+            max_cost_per_hour: Maximum cost per hour in USD (None = unlimited)
+            enable_cost_logging: Log cost estimates for each call
+        """
+        if model not in self.MODELS:
+            raise ValueError(f"Unknown model: {model}")
+        self.model_name = model
+        self.model_config = self.MODELS[model]
+        self.model_id = self.model_config["id"]
+        self.temperature = temperature
+        self.max_tokens = min(max_tokens, self.model_config["max_tokens"])
+        self.bedrock = boto3.client('bedrock-runtime', region_name=region)
+        
+        # Token tracking
+        self.total_prompt_tokens = 0
+        self.total_completion_tokens = 0
+        
+        # Rate limiting (Issue #39)
+        self._rate_limiter: Optional[TokenBucketRateLimiter] = None
+        if enable_rate_limiting:
+            self._rate_limiter = create_rate_limiter(
+                model=model,
+                provider="bedrock",
+                rpm=rate_limit_rpm,
+                tpm=rate_limit_tpm,
+                max_cost_per_hour=max_cost_per_hour,
+                enable_cost_logging=enable_cost_logging,
+            )
+            logger.info(
+                f"Rate limiting enabled for {model}: "
+                f"{rate_limit_rpm} RPM, {rate_limit_tpm} TPM"
+                + (f", max ${max_cost_per_hour}/hr" if max_cost_per_hour else "")
+            )
+    
+    def get_token_usage(self) -> dict:
+        """Get total token usage."""
+        return {
+            "prompt_tokens": self.total_prompt_tokens,
+            "completion_tokens": self.total_completion_tokens,
+            "total_tokens": self.total_prompt_tokens + self.total_completion_tokens
+        }
+    
+    def reset_token_usage(self):
+        """Reset token counters."""
+        self.total_prompt_tokens = 0
+        self.total_completion_tokens = 0
+    
+    @llm_retry(max_attempts=3, min_wait=1.0, max_wait=10.0)
+    async def generate(self, messages: List[Dict[str, str]], **kwargs) -> str:
+        """
+        Generate a response from Bedrock with automatic retry on transient failures.
+        
+        Retries on:
+        - ThrottlingException (rate limits)
+        - ServiceUnavailableException (5xx errors)
+        - Connection timeouts
+        
+        Args:
+            messages: List of message dicts with 'role' and 'content'
+            **kwargs: Additional parameters (max_tokens, temperature)
+            
+        Returns:
+            Generated text response
+            
+        Raises:
+            LLMThrottlingError: After max retries on throttling
+            LLMServerError: After max retries on server errors
+            PermissionError: On access denied (not retried)
+            RuntimeError: On other non-retryable errors or cost limit exceeded
+        """
+        # Rate limiting (Issue #39)
+        if self._rate_limiter:
+            # Estimate tokens based on message content
+            total_chars = sum(len(m.get("content", "")) for m in messages)
+            estimated_tokens = max(total_chars // 4, 500)  # Rough estimate
+            await self._rate_limiter.acquire(estimated_tokens=estimated_tokens)
+        
+        try:
+            # Convert message format for Converse API (content must be a list)
+            formatted_messages = []
+            for msg in messages:
+                formatted_messages.append({
+                    "role": msg["role"],
+                    "content": [{"text": msg["content"]}]
+                })
+            
+            response = await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: self.bedrock.converse(
+                    modelId=self.model_id,
+                    messages=formatted_messages,
+                    inferenceConfig={
+                        "maxTokens": kwargs.get("max_tokens", self.max_tokens),
+                        "temperature": kwargs.get("temperature", self.temperature),
+                        "topP": 0.9,
+                    }
+                )
+            )
+            
+            # Track token usage from Bedrock response
+            input_tokens = 0
+            output_tokens = 0
+            if 'usage' in response:
+                input_tokens = response['usage'].get('inputTokens', 0)
+                output_tokens = response['usage'].get('outputTokens', 0)
+                self.total_prompt_tokens += input_tokens
+                self.total_completion_tokens += output_tokens
+            
+            # Record usage for rate limiting (Issue #39)
+            if self._rate_limiter:
+                self._rate_limiter.record_usage(input_tokens, output_tokens)
+            
+            return response['output']['message']['content'][0]['text']
+        except ClientError as e:
+            error_code = e.response['Error']['Code']
+            error_msg = e.response['Error']['Message']
+            
+            # Non-retryable: access denied
+            if error_code == "AccessDeniedException":
+                raise PermissionError(f"Bedrock access denied: {error_msg}")
+            
+            # Classify and potentially retry
+            classified_error = classify_boto_error(error_code, error_msg)
+            logger.warning(f"Bedrock error ({error_code}): {error_msg} - {'retrying' if isinstance(classified_error, (LLMThrottlingError, LLMServerError)) else 'not retrying'}")
+            raise classified_error
+    
+    def get_rate_limit_stats(self) -> Optional[Dict[str, Any]]:
+        """Get rate limiter statistics (if enabled)."""
+        if self._rate_limiter:
+            return self._rate_limiter.get_stats()
+        return None
+
+
+async def test_bedrock_provider():
+    print("Testing Bedrock Provider...")
+    print("=" * 70)
+    for model in ["llama-3.3-70b", "llama-4-maverick"]:
+        try:
+            print(f"\nTesting {model}...")
+            provider = BedrockProvider(model=model, max_tokens=100)
+            messages = [{"role": "user", "content": "What is 2+2?"}]
+            response = await provider.generate(messages)
+            print(f"✅ Response: {response[:100]}")
+        except Exception as e:
+            print(f"❌ Error: {str(e)[:150]}")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_bedrock_provider())

mcal/storage/__init__.py

@@ -0,0 +1 @@
+"""MCAL Storage backends."""

mcal_ai-0.1.0.dist-info/METADATA

@@ -0,0 +1,319 @@
+Metadata-Version: 2.4
+Name: mcal-ai
+Version: 0.1.0
+Summary: Memory-Context Alignment Layer for Goal-Coherent AI Agents
+Author: MCAL Team
+License: MIT
+Project-URL: Homepage, https://github.com/Shivakoreddi/mcal-ai
+Project-URL: Documentation, https://github.com/Shivakoreddi/mcal-ai#readme
+Project-URL: Repository, https://github.com/Shivakoreddi/mcal-ai.git
+Project-URL: Issues, https://github.com/Shivakoreddi/mcal-ai/issues
+Keywords: llm,memory,agents,context,ai,nlp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anthropic>=0.18.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: boto3>=1.28.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: faiss-cpu>=1.7.4
+Requires-Dist: sentence-transformers>=2.2.0
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: aiosqlite>=0.19.0
+Requires-Dist: tiktoken>=0.5.0
+Requires-Dist: tenacity>=8.2.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: langgraph
+Requires-Dist: langgraph>=0.0.40; extra == "langgraph"
+Requires-Dist: langchain-core>=0.1.0; extra == "langgraph"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.28.0; extra == "crewai"
+Provides-Extra: autogen
+Requires-Dist: pyautogen>=0.2.0; extra == "autogen"
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.1.0; extra == "langchain"
+Requires-Dist: langchain-core>=0.1.0; extra == "langchain"
+Provides-Extra: integrations
+Requires-Dist: langgraph>=0.0.40; extra == "integrations"
+Requires-Dist: langchain-core>=0.1.0; extra == "integrations"
+Requires-Dist: crewai>=0.28.0; extra == "integrations"
+Requires-Dist: pyautogen>=0.2.0; extra == "integrations"
+Provides-Extra: mem0
+Requires-Dist: mem0ai>=0.1.0; extra == "mem0"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.5.0; extra == "dev"
+Requires-Dist: pre-commit>=3.4.0; extra == "dev"
+Requires-Dist: ipykernel>=6.25.0; extra == "dev"
+Requires-Dist: jupyter>=1.0.0; extra == "dev"
+Provides-Extra: eval
+Requires-Dist: pandas>=2.0.0; extra == "eval"
+Requires-Dist: matplotlib>=3.7.0; extra == "eval"
+Requires-Dist: seaborn>=0.12.0; extra == "eval"
+Requires-Dist: wandb>=0.15.0; extra == "eval"
+Requires-Dist: scipy>=1.11.0; extra == "eval"
+Provides-Extra: all
+Requires-Dist: mcal[dev,eval,integrations]; extra == "all"
+Dynamic: license-file
+
+# MCAL: Memory-Context Alignment Layer
+
+> **Beyond Retrieval:** Intent-Preserving Memory for Goal-Coherent AI Agents
+
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![arXiv](https://img.shields.io/badge/arXiv-coming--soon-b31b1b.svg)](https://arxiv.org/)
+[![Standalone](https://img.shields.io/badge/architecture-standalone-green.svg)](docs/MCAL_DESIGN.md)
+
+## What's New in v2.0
+
+MCAL is now **fully standalone** - no external dependencies on Mem0 or other memory providers. The architecture includes:
+
+- **Built-in Embedding Service** - OpenAI or Bedrock embeddings
+- **Native Vector Search** - Cosine similarity with HNSW-like indexing  
+- **Graph Deduplication** - Automatic node merging with similarity detection
+- **JSON Persistence** - Zero-config file-based storage
+
+## The Problem
+
+Current AI agent memory systems store **facts** but lose **meaning**:
+
+| What's Stored                        | What's Lost                                      |
+|--------------------------------------|--------------------------------------------------|
+| "User wants to visit Japan"          | **WHY** they chose Japan over other destinations  |
+| "User booked a hotel in Shibuya"     | **WHAT** alternatives were considered (Shinjuku, Ginza, Asakusa) |
+| "User plans to visit Kyoto"          | **HOW** this fits into the overall trip plan      |
+
+This creates the **Memory-Context Alignment Paradox**: as conversations grow, agents remember *what* was said but forget *why* it mattered.
+
+## Our Solution: Three Pillars
+
+### 1. Intent Graph Preservation
+Hierarchical goal structures that persist across sessions:
+```
+MISSION: Plan a 2-week vacation to Japan
+├── GOAL: Book travel [✓ COMPLETED]
+│   ├── TASK: Find flights [✓]
+│   └── TASK: Reserve hotels [✓]
+├── GOAL: Plan activities [ACTIVE]
+│   ├── TASK: Research Tokyo attractions [✓]
+│   ├── TASK: Plan Kyoto day trips [IN PROGRESS]
+│   └── TASK: Book restaurants [PENDING]
+└── GOAL: Pack and prepare [PENDING]
+```
+
+### 2. Reasoning Chain Storage
+Preserve **WHY** decisions were made, not just conclusions:
+```
+Decision: "Stay in Shibuya for Tokyo accommodation"
+├── Alternatives: [Shinjuku, Ginza, Asakusa]
+├── Rationale: "Central location, good nightlife, easy metro access"
+├── Evidence: ["User wants to explore at night", "Prefers walkable areas"]
+└── Trade-offs: ["More expensive but saves daily transit time"]
+```
+
+### 3. Goal-Aware Retrieval
+Retrieve based on **objective achievement**, not just similarity:
+```
+Score = α × semantic_similarity
+      + β × goal_alignment      ← NEW
+      + γ × decision_relevance  ← NEW
+      + δ × recency_decay
+```
+
+## Installation
+
+```bash
+# Install from source (recommended)
+git clone https://github.com/Shivakoreddi/mcla-research.git
+cd mcla-research
+pip install -e .
+
+# Development installation with test dependencies
+pip install -e ".[dev]"
+
+# Optional: Install with legacy Mem0 support
+pip install -e ".[mem0]"
+```
+
+### Requirements
+- Python 3.11+
+- `anthropic` - For LLM extraction (Claude)
+- `openai` - For embeddings (optional, can use Bedrock instead)
+
+## Quick Start
+
+```python
+import asyncio
+from mcal import MCAL
+
+async def main():
+    # Initialize MCAL (standalone by default)
+    mcal = MCAL(
+        llm_provider="anthropic",  # or "bedrock", "openai"
+        embedding_provider="openai",  # or "bedrock" 
+    )
+    
+    # Add conversation messages
+    messages = [
+        {"role": "user", "content": "I'm building a fraud detection ML pipeline"},
+        {"role": "assistant", "content": "Great! Let's start with data ingestion..."},
+        {"role": "user", "content": "I chose PostgreSQL over MongoDB for the data store"},
+        {"role": "assistant", "content": "PostgreSQL is a solid choice for structured fraud data..."}
+    ]
+    
+    result = await mcal.add(messages, user_id="user_123")
+    
+    # Access the unified graph with goals, decisions, and reasoning
+    print(f"Extracted {result.unified_graph.node_count} nodes")
+    print(f"Active goals: {result.unified_graph.get_active_goals()}")
+    print(f"Decisions: {result.unified_graph.get_all_decisions_with_detail()}")
+    
+    # Search for relevant context
+    search_results = await mcal.search(
+        query="What database did the user choose?",
+        user_id="user_123"
+    )
+    
+    # Get formatted context for LLM
+    context = mcal.get_context(
+        query="What should we focus on next?",
+        user_id="user_123",
+        max_tokens=4000
+    )
+
+asyncio.run(main())
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                         MCAL v2.0                               │
+│  ┌───────────────────────────────────────────────────────────┐  │
+│  │                 Application Layer                         │  │
+│  │  mcal.add()  │  mcal.search()  │  mcal.get_context()     │  │
+│  └───────────────────────────────────────────────────────────┘  │
+│                              │                                   │
+│  ┌───────────────────────────────────────────────────────────┐  │
+│  │              Unified Deep Extractor                       │  │
+│  │    Single LLM call extracts: GOALS | DECISIONS | FACTS   │  │
+│  └───────────────────────────────────────────────────────────┘  │
+│                              │                                   │
+│  ┌───────────────────────────────────────────────────────────┐  │
+│  │              Unified Graph (6 Nodes, 13 Edges)           │  │
+│  │    PERSON | THING | CONCEPT | GOAL | DECISION | ACTION   │  │
+│  └───────────────────────────────────────────────────────────┘  │
+│                              │                                   │
+│  ┌───────────────────────────────────────────────────────────┐  │
+│  │               Standalone Services                         │  │
+│  │  ┌──────────────┐  ┌─────────────┐  ┌─────────────────┐  │  │
+│  │  │  Embeddings  │  │Vector Search│  │  Deduplication  │  │  │
+│  │  │  (OpenAI/    │  │(Cosine Sim) │  │  (Similarity    │  │  │
+│  │  │   Bedrock)   │  │             │  │   Merging)      │  │  │
+│  │  └──────────────┘  └─────────────┘  └─────────────────┘  │  │
+│  └───────────────────────────────────────────────────────────┘  │
+│                              │                                   │
+│  ┌───────────────────────────────────────────────────────────┐  │
+│  │                JSON File Persistence                      │  │
+│  │    ~/.mcal/users/{user_id}/graph.json                    │  │
+│  └───────────────────────────────────────────────────────────┘  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Project Structure
+
+```
+mcla-research/
+├── src/mcal/
+│   ├── mcal.py              # Main MCAL class
+│   ├── core/
+│   │   ├── unified_extractor.py  # Single-pass extraction
+│   │   ├── unified_graph.py      # Graph with rich attributes
+│   │   ├── embedding_service.py  # Embedding generation
+│   │   ├── vector_index.py       # Similarity search
+│   │   └── deduplication.py      # Node merging
+│   ├── providers/
+│   │   └── llm_providers.py      # Anthropic, OpenAI, Bedrock
+│   └── storage/
+│       └── sqlite_store.py       # Persistence layer
+├── experiments/
+├── data/
+│   ├── synthetic/               # Generated conversations
+│   └── benchmarks/              # MCAL-Bench dataset
+├── tests/
+└── docs/
+```
+
+## Evaluation: MCAL-Bench
+
+We introduce **MCAL-Bench**, the first benchmark for reasoning preservation and goal coherence:
+
+| Metric | What It Measures |
+|--------|------------------|
+| **RPS** (Reasoning Preservation Score) | Can the system explain WHY a decision was made? |
+| **GCS** (Goal Coherence Score) | Do responses align with user's active objectives? |
+| **TER** (Token Efficiency Ratio) | Quality-per-token vs full context baseline |
+
+## Results (Preliminary)
+
+| System | RPS | GCS | TER |
+|--------|-----|-----|-----|
+| Full Context | 0.85 | 0.82 | 1.0x |
+| Summarization | 0.45 | 0.58 | 2.1x |
+| Mem0 | 0.52 | 0.61 | 3.2x |
+| **MCAL (Ours)** | **0.78** | **0.79** | **3.8x** |
+
+## Roadmap
+
+- [x] Problem formulation & research
+- [ ] Week 1: Foundation (baseline + data)
+- [ ] Week 2: Core algorithms
+- [ ] Week 3: Benchmark & evaluation
+- [ ] Week 4: Paper draft
+- [ ] Week 5: Release & arXiv
+
+## Citation
+
+```bibtex
+@article{mcal2026,
+  title={MCAL: Memory-Context Alignment for Goal-Coherent AI Agents},
+  author={Koreddi, Shiva},
+  journal={arXiv preprint},
+  year={2026}
+}
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Acknowledgments
+
+Built on insights from:
+- [MemGPT](https://github.com/cpacker/MemGPT) - OS-inspired memory hierarchy
+- [Reflexion](https://arxiv.org/abs/2303.11366) - Verbal self-reflection
+
+---
+
+## Migration from v1.x
+
+If you were using MCAL with Mem0 backend, see [STANDALONE_MIGRATION.md](docs/STANDALONE_MIGRATION.md) for migration guide.
+
+**Key changes:**
+- `mem0_config` and `mem0_api_key` parameters are deprecated
+- `use_standalone_backend` is deprecated (standalone is now default)
+- Install `mcal[mem0]` for legacy Mem0 support

mcal_ai-0.1.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+mcal/__init__.py,sha256=8paMduzZUQ1oDhJQtt9lj01fqWohvqoo5m296Swx2pY,4276
+mcal/mcal.py,sha256=-CIODdF6XK6cnFjJBvSEy_3dcZOFjP1tuXFf2LoAvDE,69662
+mcal/backends/__init__.py,sha256=bYNXulnb39Fl6BSpqb7sEswJIORVnY9pe1L2-qTY2Bk,1200
+mcal/backends/base.py,sha256=zELlkIuqPG7Kk11j_gF0rvCaYAey_mPm0jvHSGOIJ_Y,11683
+mcal/baselines/__init__.py,sha256=0CnVJQxNp9sHfUCMxyBGoWjijlBmYV4hIprETWzuD-E,52
+mcal/core/__init__.py,sha256=EWpI1hJrozDcx0T7QxmRGNZDC5xaA5W0JyRjMuRZRXo,2205
+mcal/core/embeddings.py,sha256=mqXhuyDAfqctSZSEQPTe8ZhuSKS0ZwflVKt1RYqX0wY,8465
+mcal/core/extraction_cache.py,sha256=YJKJIDmPrnhWQYq1WS6qDnDlC28gjWRpl7QkERLhn1M,13717
+mcal/core/goal_retriever.py,sha256=WlkyL6Wk3GBMQHsBGtVWnblnZdC9CDyhwvDixVLwujI,17946
+mcal/core/intent_tracker.py,sha256=KDTlhiVA4CZrD9rMyt2syTsOMQqRB9U7yspDlpBZxRo,25322
+mcal/core/models.py,sha256=CSC3lqeaVovP8B-R4eU720PbCef4fYLUWGr2vT-wfKc,15505
+mcal/core/rate_limiter.py,sha256=L1vUwWvtVrrIy5EDIZxWGEGxYtiP9sfmBbv8sroXAuc,14243
+mcal/core/reasoning_store.py,sha256=lj4cR7sUwWinxsMaKGkEWE5SQV0AobpvDnOjmnbIzVY,38277
+mcal/core/retry.py,sha256=fM9xhIEUMKROGxWG02j_aZqE6dz7QL5EGK_UdcPWsAk,5488
+mcal/core/storage.py,sha256=sB6d49d1Z8ez4RTVEOOhJA6RefKyNfgybMj8ubtJVkU,15309
+mcal/core/streaming.py,sha256=9Og_RO8AK3l15Dfwkc_Lz6TV_AHzvv0sIqtVXvtSFcs,7402
+mcal/core/unified_extractor.py,sha256=GFxSGxarHVG6hz2L1biIgyiNGXOldPdFvqH_QbyInRM,53172
+mcal/core/vector_index.py,sha256=Z67ZuKh0Vol8zeQ0ruFJ94x9vzesMWtcmKt7O6Q3MvM,6091
+mcal/evaluation/__init__.py,sha256=J1JtxdEVFocjJKk0nhuqoagpRVmuCpa46xKOonq5m0s,46
+mcal/integrations/__init__.py,sha256=4YN2Rg1ZG38qN-SyVgb6DYE4Gj6zaXGy8jtr32bmGEc,2878
+mcal/integrations/autogen.py,sha256=uaIEAktLsl8mgEc64PK1Nu9vQJDy9PAXiXWvf57_gLk,2593
+mcal/integrations/crewai.py,sha256=FVfOWxnKnxhXB7KEhLgQMdEv5HFv2OK0RfDPcH3jTZ4,2462
+mcal/integrations/langchain.py,sha256=J_xOUIUoWYcTA5iFiwyt9rTLt1R4lltAJ3hj957B4Vs,3171
+mcal/integrations/langgraph.py,sha256=nIE7U9aQQLgG_qRQmZuy2ZOJbg_ZRCIbmYOWc0bZklA,1257
+mcal/providers/bedrock.py,sha256=zUI07KouzOAXfMgDwloJuor0COElIBrE5_PVtjn6g7E,8632
+mcal/storage/__init__.py,sha256=9CsHK4EtBOoSk04EcOFzCAP8LjvqX3K2ZE-hxA96jPU,29
+mcal_ai-0.1.0.dist-info/licenses/LICENSE,sha256=zdp5kxDzb-kYvBiEZ_h1Hi96z-o6e5oXoXFx2IIefCs,1062
+mcal_ai-0.1.0.dist-info/METADATA,sha256=MK_rggbEuc13eRezR3xHVIproSKNJ_RrZXdTjx6_KL8,14262
+mcal_ai-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mcal_ai-0.1.0.dist-info/entry_points.txt,sha256=ICilsPI5krXkoM9espdv7jtJnRMO2hTdTcwiocNDfJs,39
+mcal_ai-0.1.0.dist-info/top_level.txt,sha256=aJ6Ay5tUlQgkrlbGXc90wuOWQpncaHNFN036i9hIWj0,5
+mcal_ai-0.1.0.dist-info/RECORD,,

mcal_ai-0.1.0.dist-info/WHEEL

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

mcal_ai-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcal = mcal.cli:main

mcal_ai-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shiva
+
+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.

mcal_ai-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mcal