@macaw-ai/client 0.0.0-stage → 0.9.10

package/payload/secureAI/examples/langchain/langchain_1d_llm_openai.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""
+langchain_1d_llm_openai.py - SecureChatOpenAI drop-in replacement
+
+Drop-in replacement for langchain_openai.ChatOpenAI with MACAW protection.
+Demonstrates invoke and streaming with audit logging.
+
+Use this when: You want MACAW security on LangChain OpenAI calls without
+changing your application code.
+
+Prerequisites:
+    - MACAW SDK installed (pip install macaw-client macaw-adapters)
+    - OPENAI_API_KEY environment variable
+
+Run:
+    export OPENAI_API_KEY=sk-...
+    python langchain_1d_llm_openai.py
+"""
+
+import os
+
+# BEFORE: from langchain_openai import ChatOpenAI
+# AFTER:
+from macaw_adapters.langchain.openai import ChatOpenAI, cleanup
+
+
+def main():
+    # Check for API key
+    if not os.environ.get("OPENAI_API_KEY"):
+        print("Set OPENAI_API_KEY environment variable")
+        print("  export OPENAI_API_KEY=sk-...")
+        return
+
+    print("=" * 60)
+    print("Example 1d: SecureChatOpenAI (LangChain)")
+    print("=" * 60)
+    print("\nPattern: Drop-in replacement for langchain_openai.ChatOpenAI")
+    print("Use when: Add MACAW audit logging to LangChain OpenAI calls")
+    print("\nImport change:")
+    print("  BEFORE: from langchain_openai import ChatOpenAI")
+    print("  AFTER:  from macaw_adapters.langchain.openai import ChatOpenAI")
+
+    # Create SecureChatOpenAI - same API as langchain_openai.ChatOpenAI
+    print("\n--- Creating SecureChatOpenAI ---")
+    llm = ChatOpenAI(
+        model="gpt-3.5-turbo",
+        temperature=0.7,
+        max_tokens=100
+    )
+    print(f"Model: {llm.model_name}")
+    print(f"Temperature: {llm.temperature}")
+
+    # Test 1: Basic invoke
+    print("\n--- Test 1: Basic invoke ---")
+    try:
+        response = llm.invoke("What is 2 + 2? Answer in one word.")
+        print(f"Response: {response.content}")
+        print("(This call was audit-logged by MACAW)")
+    except Exception as e:
+        print(f"Error: {e}")
+
+    # Test 2: Invoke with message list
+    print("\n--- Test 2: Invoke with messages ---")
+    try:
+        from langchain_core.messages import HumanMessage, SystemMessage
+        messages = [
+            SystemMessage(content="You are a helpful assistant. Be concise."),
+            HumanMessage(content="Name three primary colors.")
+        ]
+        response = llm.invoke(messages)
+        print(f"Response: {response.content}")
+    except ImportError:
+        print("Skipping (langchain_core not installed)")
+    except Exception as e:
+        print(f"Error: {e}")
+
+    # Test 3: Streaming
+    print("\n--- Test 3: Streaming ---")
+    try:
+        print("Response: ", end="", flush=True)
+        for chunk in llm.stream("Count from 1 to 5, one number per line."):
+            if hasattr(chunk, 'content'):
+                print(chunk.content, end="", flush=True)
+            else:
+                print(chunk, end="", flush=True)
+        print("\n(Streaming call was audit-logged by MACAW)")
+    except Exception as e:
+        print(f"\nError: {e}")
+
+    # Test 4: Batch
+    print("\n--- Test 4: Batch ---")
+    try:
+        prompts = [
+            "What color is the sky? One word.",
+            "What color is grass? One word."
+        ]
+        responses = llm.batch(prompts)
+        for i, resp in enumerate(responses):
+            print(f"  Q{i+1}: {prompts[i]}")
+            print(f"  A{i+1}: {resp.content}")
+    except Exception as e:
+        print(f"Error: {e}")
+
+    # Cleanup
+    print("\n--- Cleanup ---")
+    cleanup()
+
+    print("\n" + "=" * 60)
+    print("Example complete!")
+    print("=" * 60)
+    print("\nKey points:")
+    print("  - Same API as langchain_openai.ChatOpenAI")
+    print("  - All calls audit-logged through MACAW")
+    print("  - Supports invoke, stream, batch, and async variants")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        err = str(e)
+        print("\n" + "=" * 60)
+        if "OPENAI_API_KEY" in err or "api_key" in err.lower():
+            print("ERROR: OpenAI API key not configured")
+            print("Fix: export OPENAI_API_KEY=sk-...")
+        else:
+            print(f"ERROR: {e}")
+        print("=" * 60)
+        import sys
+        sys.exit(1)

package/payload/secureAI/examples/langchain/langchain_1e_llm_anthropic.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""
+langchain_1e_llm_anthropic.py - SecureChatAnthropic drop-in replacement
+
+Drop-in replacement for langchain_anthropic.ChatAnthropic with MACAW protection.
+Demonstrates invoke and streaming with audit logging.
+
+Use this when: You want MACAW security on LangChain Anthropic calls without
+changing your application code.
+
+Prerequisites:
+    - MACAW SDK installed (pip install macaw-client macaw-adapters)
+    - ANTHROPIC_API_KEY environment variable
+
+Run:
+    export ANTHROPIC_API_KEY=sk-ant-...
+    python langchain_1e_llm_anthropic.py
+"""
+
+import os
+
+# BEFORE: from langchain_anthropic import ChatAnthropic
+# AFTER:
+from macaw_adapters.langchain.anthropic import ChatAnthropic, cleanup
+
+
+def main():
+    # Check for API key
+    if not os.environ.get("ANTHROPIC_API_KEY"):
+        print("Set ANTHROPIC_API_KEY environment variable")
+        print("  export ANTHROPIC_API_KEY=sk-ant-...")
+        return
+
+    print("=" * 60)
+    print("Example 1e: SecureChatAnthropic (LangChain)")
+    print("=" * 60)
+    print("\nPattern: Drop-in replacement for langchain_anthropic.ChatAnthropic")
+    print("Use when: Add MACAW audit logging to LangChain Anthropic calls")
+    print("\nImport change:")
+    print("  BEFORE: from langchain_anthropic import ChatAnthropic")
+    print("  AFTER:  from macaw_adapters.langchain.anthropic import ChatAnthropic")
+
+    # Create SecureChatAnthropic - same API as langchain_anthropic.ChatAnthropic
+    print("\n--- Creating SecureChatAnthropic ---")
+    llm = ChatAnthropic(
+        model="claude-3-haiku-20240307",  # Fast model for demo
+        temperature=0.7,
+        max_tokens=100
+    )
+    print(f"Model: {llm.model_name}")
+    print(f"Temperature: {llm.temperature}")
+
+    # Test 1: Basic invoke
+    print("\n--- Test 1: Basic invoke ---")
+    try:
+        response = llm.invoke("What is 2 + 2? Answer in one word.")
+        print(f"Response: {response.content}")
+        print("(This call was audit-logged by MACAW)")
+    except Exception as e:
+        print(f"Error: {e}")
+
+    # Test 2: Invoke with message list
+    print("\n--- Test 2: Invoke with messages ---")
+    try:
+        from langchain_core.messages import HumanMessage, SystemMessage
+        messages = [
+            SystemMessage(content="You are a helpful assistant. Be concise."),
+            HumanMessage(content="Name three primary colors.")
+        ]
+        response = llm.invoke(messages)
+        print(f"Response: {response.content}")
+    except ImportError:
+        print("Skipping (langchain_core not installed)")
+    except Exception as e:
+        print(f"Error: {e}")
+
+    # Test 3: Streaming
+    print("\n--- Test 3: Streaming ---")
+    try:
+        print("Response: ", end="", flush=True)
+        for chunk in llm.stream("Count from 1 to 5, one number per line."):
+            if hasattr(chunk, 'content'):
+                print(chunk.content, end="", flush=True)
+            else:
+                print(chunk, end="", flush=True)
+        print("\n(Streaming call was audit-logged by MACAW)")
+    except Exception as e:
+        print(f"\nError: {e}")
+
+    # Test 4: Batch
+    print("\n--- Test 4: Batch ---")
+    try:
+        prompts = [
+            "What color is the sky? One word.",
+            "What color is grass? One word."
+        ]
+        responses = llm.batch(prompts)
+        for i, resp in enumerate(responses):
+            print(f"  Q{i+1}: {prompts[i]}")
+            print(f"  A{i+1}: {resp.content}")
+    except Exception as e:
+        print(f"Error: {e}")
+
+    # Cleanup
+    print("\n--- Cleanup ---")
+    cleanup()
+
+    print("\n" + "=" * 60)
+    print("Example complete!")
+    print("=" * 60)
+    print("\nKey points:")
+    print("  - Same API as langchain_anthropic.ChatAnthropic")
+    print("  - All calls audit-logged through MACAW")
+    print("  - Supports invoke, stream, batch, and async variants")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        err = str(e)
+        print("\n" + "=" * 60)
+        if "ANTHROPIC_API_KEY" in err or "api_key" in err.lower():
+            print("ERROR: Anthropic API key not configured")
+            print("Fix: export ANTHROPIC_API_KEY=sk-ant-...")
+        else:
+            print(f"ERROR: {e}")
+        print("=" * 60)
+        import sys
+        sys.exit(1)

package/payload/secureAI/examples/langchain/langchain_1f_memory.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""
+langchain_1f_memory.py - Secure Memory with MACAW context backing
+
+Drop-in replacement for LangChain memory classes with MACAW context backing.
+Demonstrates multi-session isolation where each user gets separate memory.
+
+Use this when: You want conversation memory backed by MACAW's secure context
+vault with audit logging and session isolation.
+
+Prerequisites:
+    - MACAW SDK installed (pip install macaw-client macaw-adapters)
+    - OPENAI_API_KEY environment variable (optional, for LLM demo)
+
+Run:
+    python langchain_1f_memory.py
+    # Or with OpenAI demo:
+    export OPENAI_API_KEY=sk-...
+    python langchain_1f_memory.py
+"""
+
+import os
+
+# BEFORE: from langchain.memory import ConversationBufferMemory
+# AFTER:
+from macaw_adapters.langchain.memory import (
+    ConversationBufferMemory,
+    ConversationBufferWindowMemory,
+    cleanup
+)
+from macaw_adapters.langchain.openai import ChatOpenAI
+
+
+def demonstrate_basic_memory():
+    """Basic memory usage."""
+    print("\n--- Basic ConversationBufferMemory ---")
+
+    memory = ConversationBufferMemory(session_id="demo-session")
+
+    # Simulate conversation
+    memory.save_context(
+        {"input": "Hi, my name is Alice"},
+        {"output": "Hello Alice! How can I help you today?"}
+    )
+    memory.save_context(
+        {"input": "What's the weather like?"},
+        {"output": "I don't have real-time weather data, but I can help you find it."}
+    )
+
+    # Load memory
+    history = memory.load_memory_variables({})
+    print(f"Conversation history:\n{history['history']}")
+    print("\n(All memory operations audit-logged by MACAW)")
+
+    return memory
+
+
+def demonstrate_multi_session():
+    """Multi-session isolation - each user gets separate memory."""
+    print("\n--- Multi-Session Isolation ---")
+    print("Each user has isolated memory (different session_id)")
+
+    # Alice's session
+    alice_memory = ConversationBufferMemory(session_id="alice-session")
+    alice_memory.save_context(
+        {"input": "I want to order pizza"},
+        {"output": "What toppings would you like?"}
+    )
+    alice_memory.save_context(
+        {"input": "Pepperoni please"},
+        {"output": "One pepperoni pizza coming up!"}
+    )
+
+    # Bob's session (completely isolated)
+    bob_memory = ConversationBufferMemory(session_id="bob-session")
+    bob_memory.save_context(
+        {"input": "I need help with my order"},
+        {"output": "Of course! What's your order number?"}
+    )
+    bob_memory.save_context(
+        {"input": "Order #12345"},
+        {"output": "I found your order. How can I help?"}
+    )
+
+    # Show isolation
+    print("\nAlice's memory:")
+    alice_hist = alice_memory.load_memory_variables({})
+    print(f"  {alice_hist['history']}")
+
+    print("\nBob's memory:")
+    bob_hist = bob_memory.load_memory_variables({})
+    print(f"  {bob_hist['history']}")
+
+    print("\n(Sessions are isolated - Bob can't see Alice's conversation)")
+
+    return alice_memory, bob_memory
+
+
+def demonstrate_window_memory():
+    """Window memory - only keeps last k turns."""
+    print("\n--- ConversationBufferWindowMemory (k=2) ---")
+    print("Only keeps last 2 conversation turns")
+
+    memory = ConversationBufferWindowMemory(k=2, session_id="window-demo")
+
+    # Add 4 turns
+    conversations = [
+        ("Turn 1: Hello", "Hi there!"),
+        ("Turn 2: How are you?", "I'm doing well!"),
+        ("Turn 3: What's your name?", "I'm an AI assistant."),
+        ("Turn 4: Can you help me?", "Of course! What do you need?"),
+    ]
+
+    for user_msg, ai_msg in conversations:
+        memory.save_context({"input": user_msg}, {"output": ai_msg})
+
+    # Only last 2 turns should be visible
+    history = memory.load_memory_variables({})
+    print(f"Window memory (last 2 turns only):\n{history['history']}")
+
+    return memory
+
+
+def demonstrate_with_llm():
+    """Use memory with actual LLM (if API key available)."""
+    if not os.environ.get("OPENAI_API_KEY"):
+        print("\n--- Skipping LLM demo (no OPENAI_API_KEY) ---")
+        return
+
+    print("\n--- Memory with SecureChatOpenAI ---")
+
+    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7, max_tokens=50)
+    memory = ConversationBufferMemory(session_id="llm-demo")
+
+    # First turn
+    user_input = "My favorite color is blue."
+    print(f"User: {user_input}")
+
+    response = llm.invoke(f"The user said: {user_input}. Acknowledge this.")
+    ai_output = response.content
+    print(f"AI: {ai_output}")
+
+    memory.save_context({"input": user_input}, {"output": ai_output})
+
+    # Second turn - AI should remember
+    user_input2 = "What did I just tell you?"
+    print(f"\nUser: {user_input2}")
+
+    history = memory.load_memory_variables({})
+    context = f"Previous conversation:\n{history['history']}\n\nUser: {user_input2}"
+
+    response2 = llm.invoke(context)
+    print(f"AI: {response2.content}")
+
+    memory.save_context({"input": user_input2}, {"output": response2.content})
+
+    print("\n(Memory backed by MACAW context vault)")
+
+
+def main():
+    print("=" * 60)
+    print("Example 1f: Secure Memory (LangChain)")
+    print("=" * 60)
+    print("\nPattern: Drop-in replacement for langchain.memory classes")
+    print("Use when: Need conversation memory with MACAW context backing")
+    print("\nImport change:")
+    print("  BEFORE: from langchain.memory import ConversationBufferMemory")
+    print("  AFTER:  from macaw_adapters.langchain.memory import ConversationBufferMemory")
+
+    # Demo 1: Basic memory
+    basic_memory = demonstrate_basic_memory()
+
+    # Demo 2: Multi-session isolation
+    alice_memory, bob_memory = demonstrate_multi_session()
+
+    # Demo 3: Window memory
+    window_memory = demonstrate_window_memory()
+
+    # Demo 4: With actual LLM
+    demonstrate_with_llm()
+
+    # Cleanup
+    print("\n--- Cleanup ---")
+    basic_memory.clear()
+    alice_memory.clear()
+    bob_memory.clear()
+    window_memory.clear()
+    cleanup()
+
+    print("\n" + "=" * 60)
+    print("Example complete!")
+    print("=" * 60)
+    print("\nKey points:")
+    print("  - Same API as langchain.memory classes")
+    print("  - Memory backed by MACAW context vault")
+    print("  - All operations audit-logged")
+    print("  - Session isolation via session_id")
+    print("  - Supports: ConversationBufferMemory, WindowMemory, SummaryMemory")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        err = str(e)
+        print("\n" + "=" * 60)
+        if "OPENAI_API_KEY" in err or "api_key" in err.lower():
+            print("ERROR: OpenAI API key not configured")
+            print("Fix: export OPENAI_API_KEY=sk-...")
+        else:
+            print(f"ERROR: {e}")
+        print("=" * 60)
+        import sys
+        sys.exit(1)

package/payload/secureAI/examples/litellm/litellm_1a_dropin_simple.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""
+litellm_1a_dropin_simple.py - Drop-in replacement for LiteLLM
+
+The simplest integration path - just replace your import and it works.
+No Identity Provider needed. Tests multiple providers through unified API.
+
+Prerequisites:
+    - MACAW SDK installed (pip install macaw-client macaw-adapters[litellm])
+    - OPENAI_API_KEY and/or ANTHROPIC_API_KEY environment variables
+
+Run:
+    export OPENAI_API_KEY=sk-...
+    export ANTHROPIC_API_KEY=sk-ant-...
+    python litellm_1a_dropin_simple.py
+"""
+
+import os
+import sys
+
+# BEFORE: import litellm
+# AFTER:
+from macaw_adapters.litellm import SecureLiteLLM
+
+
+def main():
+    # Check for at least one API key
+    has_openai = bool(os.environ.get("OPENAI_API_KEY"))
+    has_anthropic = bool(os.environ.get("ANTHROPIC_API_KEY"))
+
+    if not has_openai and not has_anthropic:
+        print("Set at least one API key:")
+        print("  export OPENAI_API_KEY=sk-...")
+        print("  export ANTHROPIC_API_KEY=sk-ant-...")
+        return
+
+    print("=" * 60)
+    print("Example 1a: Drop-in Replacement (LiteLLM)")
+    print("=" * 60)
+    print("\nPath: Direct on service (simplest)")
+    print("Use when: Single app, multiple providers, app-level policies")
+    print(f"\nProviders available: OpenAI={has_openai}, Anthropic={has_anthropic}")
+
+    # Define allowed models - only cheaper/faster models
+    allowed_models = []
+    if has_openai:
+        allowed_models.append("openai/gpt-3.5-turbo")
+    if has_anthropic:
+        allowed_models.append("anthropic/claude-3-haiku-20240307")
+
+    # Create SecureLiteLLM with policy restricting to allowed models
+    client = SecureLiteLLM(
+        app_name="my-litellm-app",
+        intent_policy={
+            "constraints": {
+                "parameters": {
+                    "tool:*/generate": {
+                        "model": allowed_models,
+                        "max_tokens": {"max": 200}
+                    }
+                }
+            }
+        }
+    )
+
+    print(f"\nService registered: {client.server_id}")
+    print(f"Mode: {client._mode}")
+    print(f"Policy: Only {allowed_models}, max 200 tokens")
+
+    # Test 1: OpenAI backend (if available)
+    if has_openai:
+        print("\n--- Test 1: OpenAI backend (gpt-3.5-turbo) ---")
+        response = client.chat.completions.create(
+            model="openai/gpt-3.5-turbo",
+            max_tokens=100,
+            messages=[
+                {"role": "user", "content": "What is 2+2? One word answer."}
+            ]
+        )
+        print(f"Model: {response.model}")
+        print(f"Response: {response.choices[0].message.content}")
+
+    # Test 2: Anthropic backend (if available)
+    if has_anthropic:
+        print("\n--- Test 2: Anthropic backend (claude-3-haiku) ---")
+        response = client.chat.completions.create(
+            model="anthropic/claude-3-haiku-20240307",
+            max_tokens=100,
+            messages=[
+                {"role": "user", "content": "What is 3+3? One word answer."}
+            ]
+        )
+        print(f"Model: {response.model}")
+        print(f"Response: {response.choices[0].message.content}")
+
+    # Test 3: Policy enforcement - try a blocked model
+    print("\n--- Test 3: Policy enforcement (blocked model) ---")
+    blocked_model = "openai/gpt-4" if has_openai else "anthropic/claude-3-5-sonnet-20241022"
+    print(f"Trying blocked model: {blocked_model}")
+
+    try:
+        response = client.chat.completions.create(
+            model=blocked_model,
+            max_tokens=100,
+            messages=[
+                {"role": "user", "content": "Hello"}
+            ]
+        )
+        print(f"Unexpected success - should have been blocked!")
+        print(f"Response: {response.choices[0].message.content[:50]}...")
+    except Exception as e:
+        print(f"Correctly blocked: {e}")
+
+    print("\n" + "=" * 60)
+    print("Example complete!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        err = str(e)
+        print("\n" + "=" * 60)
+        if "api_key" in err.lower():
+            print("ERROR: API key not configured")
+            print("Fix: export OPENAI_API_KEY=sk-... or ANTHROPIC_API_KEY=sk-ant-...")
+        else:
+            print(f"ERROR: {e}")
+        print("=" * 60)
+        sys.exit(1)