klira 0.0.1__tar.gz

klira-0.0.1/LICENSE

@@ -0,0 +1,164 @@
+Klira AI SDK License Agreement
+Version 1.0
+Effective Date: August 7, 2025
+
+Copyright (c) 2025 Klira AI Technologies. All rights reserved.
+
+TERMS AND CONDITIONS
+
+1. DEFINITIONS
+   "Software" refers to the Klira AI SDK source code, documentation, and any derivative works.
+   "Commercial Use" means any use of the Software (i) in connection with any business activity, 
+   (ii) in a production environment serving end users, (iii) that generates revenue directly 
+   or indirectly, (iv) by or for any commercial entity, (v) that provides competitive 
+   advantage in any commercial context, or (vi) in any organizational context where the 
+   Software supports business operations, regardless of whether monetary compensation is received.
+   "Licensor" refers to Klira AI Technologies and its authorized representatives.
+   "API Key" means the unique authentication token issued by Klira AI for accessing the Software 
+   and associated services.
+
+2. GRANT OF LICENSE
+   Subject to the terms of this Agreement, Licensor grants you a personal, non-exclusive, 
+   non-transferable, non-sublicensable, revocable license to use the Klira AI SDK solely in 
+   connection with your registered account on the Klira AI platform and for the sole purpose 
+   of developing integrations that interact with Klira AI's services.
+
+   This license is granted only upon successful registration and activation using a valid 
+   API Key issued by Klira AI. Registration requires providing accurate identification information 
+   and maintaining current contact details. API Keys are non-transferable personal licenses 
+   that expire according to the terms of your Klira AI subscription. Sharing API Keys or using 
+   expired/suspended keys constitutes unauthorized use and immediate license termination.
+
+3. LICENSE RESTRICTIONS
+   You may not:
+   • Use the SDK without a valid API Key obtained directly from Klira AI
+   • Use the SDK for any Commercial Use without explicit written permission from Klira AI
+   • Use the SDK in a production environment without a paid commercial subscription
+   • Copy, reproduce, duplicate, clone, modify, create derivative works, reverse-engineer, 
+     decompile, disassemble, or otherwise attempt to derive the source code or underlying algorithms
+   • Remove, disable, circumvent, or bypass any license validation, telemetry, security features, 
+     technical protection measures, or authentication mechanisms
+   • Redistribute, republish, resell, sublicense, or make available the SDK, in whole or in part, 
+     to any third party
+   • Use the SDK to create competing products or services
+   • Extract, isolate, or separate individual components of the SDK for independent use
+   • Use automated tools or scripts to access or interact with the SDK beyond normal operation
+   • Use the SDK in violation of any applicable laws, export regulations, or sanctions
+   • Share, transfer, or disclose your API Key to any third party
+
+4. OWNERSHIP AND INTELLECTUAL PROPERTY
+   Klira AI retains all rights, title, and interest in and to the SDK, including all intellectual 
+   property rights, patents, trademarks, trade secrets, and proprietary information. This 
+   Agreement does not grant you ownership of any portion of the SDK.
+   
+   Any modifications, enhancements, customizations, or derivative works created using or 
+   incorporating the SDK shall be deemed work-for-hire owned exclusively by Klira AI. You hereby 
+   assign all right, title, and interest in such works to Klira AI, including all intellectual 
+   property rights therein.
+
+5. TECHNICAL PROTECTION MEASURES
+   The SDK incorporates technical protection measures including but not limited to license 
+   validation, usage tracking, API key authentication, telemetry systems, anti-tampering 
+   mechanisms, and code obfuscation. You acknowledge that:
+   
+   • Circumventing, disabling, modifying, or attempting to bypass these measures constitutes 
+     a material breach of this Agreement and may violate applicable law including the Digital 
+     Millennium Copyright Act
+   • The SDK may validate your API Key and transmit metadata (e.g., usage statistics, SDK version, 
+     error reports, system information) to Klira AI servers for license enforcement, security auditing, 
+     and product improvement
+   • Klira AI may implement additional technical protection measures at any time
+   • You consent to all telemetry and monitoring activities described herein
+
+6. COMPLIANCE AND AUDIT
+   Klira AI reserves the right to audit your use of the SDK through technical means including but 
+   not limited to telemetry monitoring, usage analytics, periodic compliance verification, 
+   and on-site inspections (with reasonable notice). You agree to:
+   
+   • Cooperate fully with reasonable audit requests
+   • Provide access to systems, records, and personnel as needed for compliance verification
+   • Maintain accurate records of SDK usage and API Key management
+   • Immediately report any suspected unauthorized use or security breaches
+
+7. TERMINATION
+   This license is automatically terminated if you:
+   • Use the SDK without a valid API Key or with an expired/suspended key
+   • Breach any term of this Agreement
+   • Attempt to circumvent any technical enforcement mechanisms
+   • Fail to cooperate with compliance audits
+   • Use the SDK for Commercial Use without proper authorization
+
+   Upon termination, you must immediately:
+   • Cease all use of the SDK
+   • Destroy all copies of the SDK in your possession or control
+   • Remove any SDK components from your systems
+   • Provide written certification of compliance with these termination obligations
+
+   Sections 4, 8, 9, 10, 11, 13, and 14 shall survive termination of this Agreement.
+
+8. COMMERCIAL LICENSING
+   Commercial Use requires a separate commercial license agreement with Klira AI. Contact 
+   hello@klira.ai to discuss commercial licensing terms, which may include:
+   • Revenue sharing arrangements
+   • Volume-based licensing fees
+   • Enhanced support and service level agreements
+   • Custom terms for enterprise deployments
+
+9. LEGAL REMEDIES AND ENFORCEMENT
+   You acknowledge that breach of this Agreement would cause immediate and irreparable harm 
+   to Klira AI for which monetary damages would be inadequate. Therefore, Klira AI shall be entitled 
+   to seek:
+   
+   • Immediate injunctive relief and specific performance
+   • Temporary and permanent restraining orders
+   • Seizure and impoundment of infringing materials
+   • Damages including lost profits, statutory damages, and attorneys' fees
+   • Any other relief deemed just and proper by a court of competent jurisdiction
+   
+   These remedies are cumulative and in addition to any other rights available at law or equity.
+
+10. WARRANTIES AND DISCLAIMERS
+    The SDK is provided "AS IS" without warranty of any kind. Klira AI disclaims all warranties, 
+    express or implied, including but not limited to implied warranties of merchantability, 
+    fitness for a particular purpose, non-infringement, and quiet enjoyment.
+    
+    Klira AI does not warrant that the SDK will be uninterrupted, error-free, or secure.
+
+11. LIMITATION OF LIABILITY
+    IN NO EVENT SHALL KLIRA AI BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, 
+    PUNITIVE, OR EXEMPLARY DAMAGES ARISING FROM OR RELATING TO THIS AGREEMENT OR YOUR USE 
+    OF THE SDK, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+    
+    KLIRA AI'S TOTAL LIABILITY SHALL NOT EXCEED THE AMOUNT PAID BY YOU FOR THE SDK IN THE 
+    TWELVE MONTHS PRECEDING THE CLAIM.
+
+12. EXPORT COMPLIANCE
+    You acknowledge that the SDK may be subject to export control laws and regulations. 
+    You agree to comply with all applicable export laws and will not export, re-export, 
+    or transfer the SDK in violation of such laws.
+
+13. GOVERNING LAW AND JURISDICTION
+    This Agreement is governed by and construed in accordance with the laws of the State 
+    of Delaware, United States, without regard to conflict of laws principles. Any disputes 
+    arising under this Agreement shall be subject to the exclusive jurisdiction of the 
+    federal and state courts located in Delaware.
+
+14. GENERAL PROVISIONS
+    • This Agreement constitutes the entire agreement between the parties
+    • Any modifications must be in writing and signed by both parties
+    • If any provision is found unenforceable, the remainder shall remain in full force
+    • Waiver of any breach does not constitute waiver of any other breach
+    • This Agreement is binding upon successors and assigns
+    • Section headings are for convenience only and do not affect interpretation
+
+15. CONTACT INFORMATION
+    For licensing questions, commercial inquiries, or technical support:
+    Email: hello@klira.ai
+    Website: https://klira.ai
+
+NOTICE: This software is proprietary and confidential. Unauthorized copying, redistribution, 
+modification, reverse engineering, or use without a valid API Key is strictly prohibited 
+and may result in civil and criminal penalties under applicable law.
+
+BY USING THE KLIRA AI SDK, YOU ACKNOWLEDGE THAT YOU HAVE READ, UNDERSTOOD, AND AGREE TO BE 
+BOUND BY THE TERMS OF THIS AGREEMENT.

klira-0.0.1/NOTICE

@@ -0,0 +1,30 @@
+Klira AI SDK
+Copyright 2025 Klira AI Technologies
+Licensed under the Klira AI SDK License Agreement v1.0
+
+PROPRIETARY SOFTWARE - COMMERCIAL USE REQUIRES LICENSE
+
+This software requires a valid API key for operation.
+Visit https://klira.ai/ to obtain an API key.
+
+This software includes third-party components licensed under Apache License 2.0:
+
+1. Traceloop SDK
+   Copyright 2024 Traceloop
+   Licensed under the Apache License, Version 2.0
+   https://github.com/traceloop/openllmetry
+
+2. OpenTelemetry
+   Copyright 2024 OpenTelemetry Authors
+   Licensed under the Apache License, Version 2.0
+   https://github.com/open-telemetry/opentelemetry-python
+
+3. OpenTelemetry SDK
+   Copyright 2024 OpenTelemetry Authors
+   Licensed under the Apache License, Version 2.0
+   https://github.com/open-telemetry/opentelemetry-python/tree/main/opentelemetry-sdk
+
+4. OpenTelemetry OTLP Exporters
+   Copyright 2024 OpenTelemetry Authors
+   Licensed under the Apache License, Version 2.0
+   https://github.com/open-telemetry/opentelemetry-python/tree/main/exporter/opentelemetry-exporter-otlp

klira-0.0.1/PKG-INFO

@@ -0,0 +1,346 @@
+Metadata-Version: 2.3
+Name: klira
+Version: 0.0.1
+Summary: Klira AI SDK for LLM observability and policy enforcement
+License: Proprietary
+Keywords: llm,observability,policy,governance,tracing,opentelemetry
+Author: Klira AI Team
+Author-email: hello@getklira.com
+Requires-Python: >=3.10,<4
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: colorama (>=0.4.6)
+Requires-Dist: opentelemetry-api (>=1.28.0)
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc (>=1.28.0)
+Requires-Dist: opentelemetry-exporter-otlp-proto-http (>=1.28.0)
+Requires-Dist: opentelemetry-sdk (>=1.28.0)
+Requires-Dist: pydantic (>=1)
+Requires-Dist: traceloop-sdk (>=0.38.12)
+Project-URL: Documentation, https://docs.getklira.com
+Project-URL: Repository, https://github.com/kliraai/kliraai-sdk
+Description-Content-Type: text/markdown
+
+# Klira SDK: Universal Framework Integration
+
+Klira SDK provides a unified approach to adding observability, tracing, and guardrails to your LLM applications, regardless of which framework you use.
+
+## Key Features
+
+- **Universal Framework Support**: Works with OpenAI Agents SDK, LangChain, CrewAI, LlamaIndex, or custom agents
+- **Automated Framework Detection**: Automatically detects which framework you're using
+- **Unified Decorators**: One set of decorators that adapt to any framework
+- **Built-in Guardrails**: Apply content policies and safety guardrails to any agent
+
+## Quickstart
+
+Install the SDK:
+
+```bash
+pip install klira-sdk
+```
+
+Initialize the SDK:
+
+```python
+from klira.sdk import Klira
+
+klira = Klira.init(
+    app_name="MyApplication",
+    api_key="your-api-key",  # Set KLIRA_API_KEY env var instead for better security
+    enabled=True
+)
+```
+
+## Using with Any Framework
+
+Klira SDK provides a single, unified set of decorators that automatically adapt to whatever framework you're using.
+
+### Example: OpenAI Agents SDK
+
+```python
+from klira.sdk.decorators import tool, workflow, guardrails
+from agents import Agent, Runner
+
+# Create tool function
+@tool(name="weather", organization_id="demo_org", project_id="weather_app")
+def get_weather(city: str) -> str:
+    """Get the weather for a city."""
+    return f"The weather in {city} is sunny and 75°F."
+
+# Create agent
+agent = Agent(
+    name="WeatherBot",
+    instructions="You are a helpful weather assistant.",
+    tools=[get_weather]
+)
+
+# Create workflow
+@workflow(name="weather_workflow", organization_id="demo_org", project_id="weather_app")
+@guardrails()  # Apply guardrails automatically
+async def run_weather_agent(query: str, conversation_id: str, user_id: str):
+    """Run the weather agent with guardrails."""
+    result = await Runner.run(agent, query)
+    return result.final_output
+```
+
+### Example: LangChain
+
+```python
+from klira.sdk.decorators import tool, workflow, guardrails
+from langchain.agents import AgentExecutor, create_openai_tools_agent
+from langchain.tools import BaseTool
+from langchain_openai import ChatOpenAI
+
+# Create tool
+@tool(name="calculator", organization_id="demo_org", project_id="math_app")
+def calculator(expression: str) -> str:
+    """Calculate a math expression."""
+    return str(eval(expression))
+
+# Create agent
+llm = ChatOpenAI()
+tools = [calculator]
+agent = create_openai_tools_agent(llm, tools, "You are a math assistant.")
+agent_executor = AgentExecutor(agent=agent, tools=tools)
+
+# Create workflow
+@workflow(name="math_workflow", organization_id="demo_org", project_id="math_app")
+@guardrails()  # Apply guardrails automatically
+def run_math_agent(query: str, conversation_id: str, user_id: str):
+    """Run the math agent with guardrails."""
+    return agent_executor.invoke({"input": query})["output"]
+```
+
+## One SDK for All Frameworks
+
+The same decorator pattern works across all supported frameworks:
+
+- OpenAI Agents SDK
+- LangChain
+- CrewAI
+- LlamaIndex
+- Custom LLM applications
+
+## Built-in Guardrails
+
+Apply guardrails to any agent with the `@guardrails()` decorator:
+
+```python
+@guardrails()  # Automatic framework detection
+def run_agent(query):
+    # Your agent code here
+    pass
+```
+
+Or specify the framework explicitly:
+
+```python
+@guardrails(framework="agents_sdk")
+def run_agent(query):
+    # Your agent code here
+    pass
+```
+
+## Examples
+
+Check out the `examples/` directory for complete examples of using Klira SDK with different frameworks:
+
+- `examples/openai_agents_unified_example.py` - OpenAI Agents SDK example
+- `examples/langchain_unified_example.py` - LangChain example
+- `examples/crewai_unified_example.py` - CrewAI example
+- `examples/llama_index_unified_example.py` - LlamaIndex example
+
+## Hierarchical Tracing
+
+Klira SDK allows you to track operations at multiple levels:
+
+- **Organization**: The top level, representing your company
+- **Project**: A specific project or application
+- **Agent**: An LLM agent that performs tasks
+- **Tool**: A utility function used by an agent
+- **Task**: An individual operation or function
+- **Conversation**: A series of interactions with an LLM
+- **User**: The end-user of your application
+
+You can set these contexts using decorators or manually:
+
+```python
+from klira.sdk.tracing import set_organization, set_project, set_hierarchy_context
+
+# Set individual contexts
+set_organization("acme_corp")
+set_project("contract_analysis")
+
+# Or set the entire hierarchy at once
+set_hierarchy_context(
+    organization_id="acme_corp",
+    project_id="contract_analysis",
+    agent_id="legal_assistant",
+    task_id="data_extraction",
+    tool_id="legal_search",
+    conversation_id="conv_12345",
+    user_id="user_6789"
+)
+```
+
+## Policy Enforcement and Guardrails
+
+Klira SDK includes a powerful guardrails system for enforcing company policies:
+
+```python
+from klira.sdk import Klira
+
+# Initialize with policies path and optional LLM service
+Klira.init(
+    app_name="my_llm_app",
+    api_key="your_klira_api_key",
+    policies_path="./my_policies",  # Optional, defaults to ./guardrails
+    llm_service=my_llm_service      # Optional, uses DefaultLLMService if not provided
+)
+
+# Process a user message
+guardrails = Klira.get_guardrails()
+result = await guardrails.process_message(
+    message="Can you help me fire an employee without documentation?",
+    context={"conversation_id": "conv_123"}
+)
+
+if not result["allowed"]:
+    print(f"Message blocked: {result['blocked_reason']}")
+    print(f"Violated policies: {result['violated_policies']}")
+else:
+    # Continue processing the message
+    pass
+
+# Augment a system prompt with policy guidelines
+augmented_prompt = await guardrails.augment_system_prompt(
+    system_prompt="You are a helpful assistant.",
+    context={"matched_policies": [...]}
+)
+```
+
+The guardrails system uses a multi-layered approach:
+1. **Fast Rules Engine**: Pattern matching for quick policy evaluation
+2. **Policy Augmentation**: Enhances prompts with policy guidelines
+3. **LLM Fallback**: For sophisticated policy evaluation in edge cases
+
+## OpenTelemetry Integration
+
+Klira SDK uses OpenTelemetry for observability. To send data to your own OpenTelemetry collector:
+
+```python
+# Connect to your OpenTelemetry collector
+Klira.init(
+    app_name="my_llm_app",
+    opentelemetry_endpoint="http://your-opentelemetry-collector:4318"
+)
+
+# Or with environment variables
+# KLIRA_OPENTELEMETRY_ENDPOINT="http://your-opentelemetry-collector:4318"
+```
+
+## Environment Variables
+
+- `KLIRA_API_KEY`: Your Klira AI API key
+- `KLIRA_OPENTELEMETRY_ENDPOINT`: Custom OpenTelemetry collector endpoint
+- `KLIRA_TELEMETRY_ENABLED`: Set to "false" to disable telemetry (default: "true")
+- `KLIRA_TRACE_CONTENT`: Set to "false" to disable content tracing (default: "true")
+- `KLIRA_TRACING_ENABLED`: Set to "false" to disable tracing (default: "true")
+- `KLIRA_METRICS_ENABLED`: Set to "false" to disable metrics (default: "true")
+- `KLIRA_LOGGING_ENABLED`: Set to "true" to enable logging (default: "false")
+- `KLIRA_POLICIES_PATH`: Path to your policy files (default: "./guardrails")
+- `KLIRA_POLICY_ENFORCEMENT`: Set to "false" to disable policy enforcement (default: "true")
+
+## Compliance Reporting
+
+The hierarchical tracing features of Klira SDK make it easy to generate compliance reports by:
+
+1. Identifying which organization and project the LLM activity belongs to
+2. Tracking which agents and tools were used
+3. Logging the specific tasks that were performed
+4. Associating activities with specific conversations and users
+5. Recording policy evaluations and enforcement actions
+
+This detailed tracing enables comprehensive audit trails and makes it simple to document compliance with your organization's policies.
+
+## Custom LLM Services
+
+You can integrate your preferred LLM provider for policy evaluation:
+
+```python
+from klira.sdk.guardrails.llm_service import OpenAILLMService
+from openai import AsyncOpenAI
+
+# Set up OpenAI client
+openai_client = AsyncOpenAI(api_key="your-openai-api-key")
+llm_service = OpenAILLMService(client=openai_client, model="gpt-4o-mini")
+
+# Initialize Klira with custom LLM service
+Klira.init(
+    app_name="my_llm_app",
+    api_key="your_klira_api_key",
+    llm_service=llm_service
+)
+```
+
+## Custom Telemetry
+
+To emit Klira AI-specific events and enable richer observability, ensure the SDK is initialized with telemetry enabled (this might involve setting specific environment variables or configuration parameters depending on your setup, e.g., `KLIRA_TELEMETRY=true` or similar if applicable based on `klira/sdk/telemetry.py`'s implementation). Then, you can capture custom events using the `Telemetry` class:
+
+```python
+from klira.sdk.telemetry import Telemetry
+
+# Example within your application code where Klira SDK is used
+def my_function():
+    # ... some operation ...
+    
+    # Capture a custom event
+    Telemetry().capture(
+        event_name="my_custom_event", 
+        properties={"key": "value", "status": "completed"}
+    )
+    
+    # ... rest of the function ...
+```
+
+Consult the `klira/sdk/telemetry.py` module for details on its initialization and usage.
+
+## Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for more information.
+
+## Project Governance
+
+Klira SDK follows a meritocratic governance model. For details about our project structure, decision-making process, and community guidelines, please see:
+
+- [Project Governance](GOVERNANCE.md) - Overall project structure and decision-making process
+- [Maintainers Guide](MAINTAINERS.md) - Guidelines for project maintainers
+- [Security Policy](SECURITY.md) - Security reporting and handling procedures
+- [Code of Conduct](CODE_OF_CONDUCT.md) - Project's code of conduct
+- [Contributing](CONTRIBUTING.md) - Contributing to Klira AI SDK guidelines
+
+## Third-Party Components
+
+This project uses several third-party components that are licensed under the Apache License 2.0:
+
+- **Traceloop SDK**: For LLM observability and tracing
+- **OpenTelemetry**: For distributed tracing and metrics
+- **OpenTelemetry SDK**: Core SDK implementation
+- **OpenTelemetry OTLP Exporters**: For exporting telemetry data
+
+For detailed attribution and license information, please see the [NOTICE](NOTICE) file included in this package.
+
+## License
+
+Proprietary - Klira SDK License Agreement v1.0
+
+This software is licensed under the Klira SDK License Agreement. Commercial use requires explicit written permission. Please see the [LICENSE](LICENSE) file for full terms.
+
+For licensing inquiries, contact: hello@getklira.com