praisonaiagents 0.0.101__tar.gz → 0.0.103__tar.gz

{praisonaiagents-0.0.101 → praisonaiagents-0.0.103}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.101
+Version: 0.0.103
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10
@@ -8,13 +8,14 @@ Requires-Dist: pydantic
 Requires-Dist: rich
 Requires-Dist: openai
 Requires-Dist: mcp>=1.6.0
+Requires-Dist: posthog>=4.0.0
 Provides-Extra: mcp
 Requires-Dist: mcp>=1.6.0; extra == "mcp"
 Requires-Dist: fastapi>=0.115.0; extra == "mcp"
 Requires-Dist: uvicorn>=0.34.0; extra == "mcp"
 Provides-Extra: memory
 Requires-Dist: chromadb>=1.0.0; extra == "memory"
-Requires-Dist: litellm>=1.50.0; extra == "memory"
+Requires-Dist: litellm>=1.72.0; extra == "memory"
 Provides-Extra: knowledge
 Requires-Dist: mem0ai>=0.1.0; extra == "knowledge"
 Requires-Dist: chromadb>=1.0.0; extra == "knowledge"
@@ -24,11 +25,13 @@ Provides-Extra: graph
 Requires-Dist: mem0ai[graph]>=0.1.0; extra == "graph"
 Requires-Dist: chromadb>=1.0.0; extra == "graph"
 Provides-Extra: llm
-Requires-Dist: litellm>=1.50.0; extra == "llm"
+Requires-Dist: litellm>=1.72.0; extra == "llm"
 Requires-Dist: pydantic>=2.4.2; extra == "llm"
 Provides-Extra: api
 Requires-Dist: fastapi>=0.115.0; extra == "api"
 Requires-Dist: uvicorn>=0.34.0; extra == "api"
+Provides-Extra: telemetry
+Requires-Dist: posthog>=4.0.0; extra == "telemetry"
 Provides-Extra: all
 Requires-Dist: praisonaiagents[memory]; extra == "all"
 Requires-Dist: praisonaiagents[knowledge]; extra == "all"
@@ -36,3 +39,4 @@ Requires-Dist: praisonaiagents[graph]; extra == "all"
 Requires-Dist: praisonaiagents[llm]; extra == "all"
 Requires-Dist: praisonaiagents[mcp]; extra == "all"
 Requires-Dist: praisonaiagents[api]; extra == "all"
+Requires-Dist: praisonaiagents[telemetry]; extra == "all"

{praisonaiagents-0.0.101 → praisonaiagents-0.0.103}/praisonaiagents/__init__.py

@@ -12,6 +12,7 @@ from .knowledge.knowledge import Knowledge
 from .knowledge.chunking import Chunking
 from .mcp.mcp import MCP
 from .session import Session
+from .memory.memory import Memory
 from .guardrails import GuardrailResult, LLMGuardrail
 from .main import (
     TaskOutput,
@@ -29,9 +30,50 @@ from .main import (
     async_display_callbacks,
 )
 
+# Telemetry support (lazy loaded)
+try:
+    from .telemetry import (
+        get_telemetry,
+        enable_telemetry,
+        disable_telemetry,
+        MinimalTelemetry,
+        TelemetryCollector
+    )
+    _telemetry_available = True
+except ImportError:
+    # Telemetry not available - provide stub functions
+    _telemetry_available = False
+    def get_telemetry():
+        return None
+    
+    def enable_telemetry(*args, **kwargs):
+        import logging
+        logging.warning(
+            "Telemetry not available. Install with: pip install praisonaiagents[telemetry]"
+        )
+        return None
+    
+    def disable_telemetry():
+        pass
+    
+    MinimalTelemetry = None
+    TelemetryCollector = None
+
 # Add Agents as an alias for PraisonAIAgents
 Agents = PraisonAIAgents
 
+# Apply telemetry auto-instrumentation after all imports
+if _telemetry_available:
+    try:
+        # Only instrument if telemetry is enabled
+        _telemetry = get_telemetry()
+        if _telemetry and _telemetry.enabled:
+            from .telemetry.integration import auto_instrument_all
+            auto_instrument_all(_telemetry)
+    except Exception:
+        # Silently fail if there are any issues
+        pass
+
 __all__ = [
     'Agent',
     'ImageAgent',
@@ -43,6 +85,7 @@ __all__ = [
     'ReflectionOutput',
     'AutoAgents',
     'Session',
+    'Memory',
     'display_interaction',
     'display_self_reflection',
     'display_instruction',
@@ -58,5 +101,10 @@ __all__ = [
     'Chunking',
     'MCP',
     'GuardrailResult',
-    'LLMGuardrail'
+    'LLMGuardrail',
+    'get_telemetry',
+    'enable_telemetry',
+    'disable_telemetry',
+    'MinimalTelemetry',
+    'TelemetryCollector'
 ] 

{praisonaiagents-0.0.101 → praisonaiagents-0.0.103}/praisonaiagents/llm/__init__.py

@@ -1,5 +1,9 @@
 import logging
 import warnings
+import os
+
+# Disable litellm telemetry before any imports
+os.environ["LITELLM_TELEMETRY"] = "False"
 
 # Suppress all relevant logs at module level
 logging.getLogger("litellm").setLevel(logging.ERROR)
@@ -17,4 +21,11 @@ logging.basicConfig(level=logging.WARNING)
 # Import after suppressing warnings
 from .llm import LLM, LLMContextLengthExceededException
 
+# Ensure telemetry is disabled after import as well
+try:
+    import litellm
+    litellm.telemetry = False
+except ImportError:
+    pass
+
 __all__ = ["LLM", "LLMContextLengthExceededException"]

{praisonaiagents-0.0.101 → praisonaiagents-0.0.103}/praisonaiagents/llm/llm.py

@@ -17,6 +17,9 @@ from ..main import (
 from rich.console import Console
 from rich.live import Live
 
+# Disable litellm telemetry before any imports
+os.environ["LITELLM_TELEMETRY"] = "False"
+
 # TODO: Include in-build tool calling in LLM class
 # TODO: Restructure so that duplicate calls are not made (Sync with agent.py)
 class LLMContextLengthExceededException(Exception):
@@ -108,6 +111,9 @@ class LLM:
     ):
         try:
             import litellm
+            # Disable telemetry
+            litellm.telemetry = False
+            
             # Set litellm options globally
             litellm.set_verbose = False
             litellm.success_callback = []

{praisonaiagents-0.0.101 → praisonaiagents-0.0.103}/praisonaiagents/memory/memory.py

@@ -6,6 +6,9 @@ import shutil
 from typing import Any, Dict, List, Optional, Union, Literal
 import logging
 
+# Disable litellm telemetry before any imports
+os.environ["LITELLM_TELEMETRY"] = "False"
+
 # Set up logger
 logger = logging.getLogger(__name__)
 
@@ -29,6 +32,13 @@ try:
 except ImportError:
     OPENAI_AVAILABLE = False
 
+try:
+    import litellm
+    litellm.telemetry = False  # Disable telemetry
+    LITELLM_AVAILABLE = True
+except ImportError:
+    LITELLM_AVAILABLE = False
+
 
 
 
@@ -340,14 +350,28 @@ class Memory:
             
         elif self.use_rag and hasattr(self, "chroma_col"):
             try:
-                from openai import OpenAI
-                client = OpenAI()
-                
-                response = client.embeddings.create(
-                    input=query,
-                    model="text-embedding-3-small"
-                )
-                query_embedding = response.data[0].embedding
+                if LITELLM_AVAILABLE:
+                    # Use LiteLLM for consistency with the rest of the codebase
+                    import litellm
+                    
+                    response = litellm.embedding(
+                        model="text-embedding-3-small",
+                        input=query
+                    )
+                    query_embedding = response.data[0]["embedding"]
+                elif OPENAI_AVAILABLE:
+                    # Fallback to OpenAI client
+                    from openai import OpenAI
+                    client = OpenAI()
+                    
+                    response = client.embeddings.create(
+                        input=query,
+                        model="text-embedding-3-small"
+                    )
+                    query_embedding = response.data[0].embedding
+                else:
+                    self._log_verbose("Neither litellm nor openai available for embeddings", logging.WARNING)
+                    return []
                 
                 resp = self.chroma_col.query(
                     query_embeddings=[query_embedding],
@@ -464,19 +488,39 @@ class Memory:
         # Store in vector database if enabled
         if self.use_rag and hasattr(self, "chroma_col"):
             try:
-                from openai import OpenAI
-                client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))  # Ensure API key is correctly set
-                
-                logger.info("Getting embeddings from OpenAI...")
-                logger.debug(f"Embedding input text: {text}")  # Log the input text
-                
-                response = client.embeddings.create(
-                    input=text,
-                    model="text-embedding-3-small"
-                )
-                embedding = response.data[0].embedding
-                logger.info("Successfully got embeddings")
-                logger.debug(f"Received embedding of length: {len(embedding)}")  # Log embedding details
+                if LITELLM_AVAILABLE:
+                    # Use LiteLLM for consistency with the rest of the codebase
+                    import litellm
+                    
+                    logger.info("Getting embeddings from LiteLLM...")
+                    logger.debug(f"Embedding input text: {text}")
+                    
+                    response = litellm.embedding(
+                        model="text-embedding-3-small",
+                        input=text
+                    )
+                    embedding = response.data[0]["embedding"]
+                    logger.info("Successfully got embeddings from LiteLLM")
+                    logger.debug(f"Received embedding of length: {len(embedding)}")
+                    
+                elif OPENAI_AVAILABLE:
+                    # Fallback to OpenAI client
+                    from openai import OpenAI
+                    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+                    
+                    logger.info("Getting embeddings from OpenAI...")
+                    logger.debug(f"Embedding input text: {text}")
+                    
+                    response = client.embeddings.create(
+                        input=text,
+                        model="text-embedding-3-small"
+                    )
+                    embedding = response.data[0].embedding
+                    logger.info("Successfully got embeddings from OpenAI")
+                    logger.debug(f"Received embedding of length: {len(embedding)}")
+                else:
+                    logger.warning("Neither litellm nor openai available for embeddings")
+                    return
                 
                 # Sanitize metadata for ChromaDB
                 sanitized_metadata = self._sanitize_metadata(metadata)
@@ -527,15 +571,28 @@ class Memory:
 
         elif self.use_rag and hasattr(self, "chroma_col"):
             try:
-                from openai import OpenAI
-                client = OpenAI()
-                
-                # Get query embedding
-                response = client.embeddings.create(
-                    input=query,
-                    model="text-embedding-3-small"  # Using consistent model
-                )
-                query_embedding = response.data[0].embedding
+                if LITELLM_AVAILABLE:
+                    # Use LiteLLM for consistency with the rest of the codebase
+                    import litellm
+                    
+                    response = litellm.embedding(
+                        model="text-embedding-3-small",
+                        input=query
+                    )
+                    query_embedding = response.data[0]["embedding"]
+                elif OPENAI_AVAILABLE:
+                    # Fallback to OpenAI client
+                    from openai import OpenAI
+                    client = OpenAI()
+                    
+                    response = client.embeddings.create(
+                        input=query,
+                        model="text-embedding-3-small"
+                    )
+                    query_embedding = response.data[0].embedding
+                else:
+                    self._log_verbose("Neither litellm nor openai available for embeddings", logging.WARNING)
+                    return []
                 
                 # Search ChromaDB with embedding
                 resp = self.chroma_col.query(
@@ -910,21 +967,44 @@ class Memory:
         """
 
         try:
-            # Use LiteLLM for consistency with the rest of the codebase
-            import litellm
-            
-            # Convert model name if it's in litellm format
-            model_name = llm or "gpt-4o-mini"
-            
-            response = litellm.completion(
-                model=model_name,
-                messages=[{
-                    "role": "user", 
-                    "content": custom_prompt or default_prompt
-                }],
-                response_format={"type": "json_object"},
-                temperature=0.3
-            )
+            if LITELLM_AVAILABLE:
+                # Use LiteLLM for consistency with the rest of the codebase
+                import litellm
+                
+                # Convert model name if it's in litellm format
+                model_name = llm or "gpt-4o-mini"
+                
+                response = litellm.completion(
+                    model=model_name,
+                    messages=[{
+                        "role": "user", 
+                        "content": custom_prompt or default_prompt
+                    }],
+                    response_format={"type": "json_object"},
+                    temperature=0.3
+                )
+            elif OPENAI_AVAILABLE:
+                # Fallback to OpenAI client
+                from openai import OpenAI
+                client = OpenAI()
+                
+                response = client.chat.completions.create(
+                    model=llm or "gpt-4o-mini",
+                    messages=[{
+                        "role": "user", 
+                        "content": custom_prompt or default_prompt
+                    }],
+                    response_format={"type": "json_object"},
+                    temperature=0.3
+                )
+            else:
+                logger.error("Neither litellm nor openai available for quality calculation")
+                return {
+                    "completeness": 0.0,
+                    "relevance": 0.0,
+                    "clarity": 0.0,
+                    "accuracy": 0.0
+                }
             
             metrics = json.loads(response.choices[0].message.content)
             

praisonaiagents-0.0.103/praisonaiagents/telemetry/__init__.py

@@ -0,0 +1,102 @@
+"""
+PraisonAI Agents Minimal Telemetry Module
+
+This module provides anonymous usage tracking with privacy-first design.
+Telemetry is opt-out and can be disabled via environment variables:
+- PRAISONAI_TELEMETRY_DISABLED=true
+- PRAISONAI_DISABLE_TELEMETRY=true  
+- DO_NOT_TRACK=true
+
+No personal data, prompts, or responses are collected.
+"""
+
+import os
+import atexit
+from typing import Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .telemetry import MinimalTelemetry, TelemetryCollector
+
+# Import the classes for real (not just type checking)
+from .telemetry import MinimalTelemetry, TelemetryCollector
+
+__all__ = [
+    'get_telemetry',
+    'enable_telemetry',
+    'disable_telemetry',
+    'MinimalTelemetry',
+    'TelemetryCollector',  # For backward compatibility
+]
+
+
+def get_telemetry() -> 'MinimalTelemetry':
+    """Get the global telemetry instance."""
+    from .telemetry import get_telemetry as _get_telemetry
+    return _get_telemetry()
+
+
+def enable_telemetry():
+    """Enable telemetry (if not disabled by environment)."""
+    from .telemetry import enable_telemetry as _enable_telemetry
+    _enable_telemetry()
+
+
+def disable_telemetry():
+    """Disable telemetry."""
+    from .telemetry import disable_telemetry as _disable_telemetry
+    _disable_telemetry()
+
+
+# Auto-instrumentation and cleanup setup
+_initialized = False
+_atexit_registered = False
+
+def _ensure_atexit():
+    """Ensure atexit handler is registered."""
+    global _atexit_registered
+    if _atexit_registered:
+        return
+    
+    # Check if telemetry should be disabled
+    telemetry_disabled = any([
+        os.environ.get('PRAISONAI_TELEMETRY_DISABLED', '').lower() in ('true', '1', 'yes'),
+        os.environ.get('PRAISONAI_DISABLE_TELEMETRY', '').lower() in ('true', '1', 'yes'),
+        os.environ.get('DO_NOT_TRACK', '').lower() in ('true', '1', 'yes'),
+    ])
+    
+    if not telemetry_disabled:
+        # Register atexit handler to flush telemetry on exit
+        atexit.register(lambda: get_telemetry().flush())
+        _atexit_registered = True
+
+def _initialize_telemetry():
+    """Initialize telemetry with auto-instrumentation and cleanup."""
+    global _initialized
+    if _initialized:
+        return
+    
+    # Ensure atexit is registered
+    _ensure_atexit()
+    
+    # Check if telemetry should be disabled
+    telemetry_disabled = any([
+        os.environ.get('PRAISONAI_TELEMETRY_DISABLED', '').lower() in ('true', '1', 'yes'),
+        os.environ.get('PRAISONAI_DISABLE_TELEMETRY', '').lower() in ('true', '1', 'yes'),
+        os.environ.get('DO_NOT_TRACK', '').lower() in ('true', '1', 'yes'),
+    ])
+    
+    if not telemetry_disabled:
+        try:
+            # Defer the actual instrumentation to avoid circular imports
+            # This will be called when get_telemetry() is first accessed
+            _initialized = True
+        except Exception:
+            # Silently fail if there are any issues
+            pass
+
+
+# No need for lazy auto-instrumentation here since main __init__.py handles it
+
+
+# Initialize atexit handler early
+_ensure_atexit()