API Key Management

# Copy example file
cp .env.example .env

# Edit with your keys
nano .env

# AI Model Providers
NEBIUS_API_KEY=your_nebius_api_key_here
OPENAI_API_KEY=sk-proj-your_openai_key_here
ANTHROPIC_API_KEY=sk-ant-your_anthropic_key_here
GOOGLE_API_KEY=your_google_ai_key_here

# Memory & Vector Databases
MEMORI_API_KEY=your_memori_api_key_here
QDRANT_URL=http://localhost:6333
QDRANT_API_KEY=your_qdrant_cloud_key_here

# Search & Web Tools
SERPAPI_API_KEY=your_serpapi_key_here
TAVILY_API_KEY=tvly-your_tavily_key_here
BRAVE_SEARCH_API_KEY=your_brave_key_here

# MCP & External Services
GITHUB_PERSONAL_ACCESS_TOKEN=ghp_your_github_token_here
SLACK_BOT_TOKEN=xoxb-your_slack_token_here

# Specialized Services
SGAI_API_KEY=your_scrapegraph_key_here
CONTEXTUAL_API_KEY=your_contextual_ai_key_here
ARIZE_PHOENIX_API_KEY=your_phoenix_key_here

NEBIUS_API_KEY=your_key_here

from agno.models.nebius import Nebius
import os
from dotenv import load_dotenv

load_dotenv()

model = Nebius(
    id="deepseek-ai/DeepSeek-V3-0324",
    api_key=os.getenv("NEBIUS_API_KEY")
)

from strands.models.litellm import LiteLLMModel
import os

model = LiteLLMModel(
    client_args={"api_key": os.getenv("NEBIUS_API_KEY")},
    model_id="nebius/deepseek-ai/DeepSeek-V3-0324"
)

OPENAI_API_KEY=sk-proj-your_key_here

from openai import OpenAI
import os

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

response = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=[{"role": "user", "content": "Hello!"}]
)

from agno.models.openai import OpenAIChat

model = OpenAIChat(
    id="gpt-4-turbo",
    api_key=os.getenv("OPENAI_API_KEY")
)

ANTHROPIC_API_KEY=sk-ant-your_key_here

from anthropic import Anthropic

client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}]
)

GOOGLE_API_KEY=your_key_here

from llama_index.llms.gemini import Gemini

llm = Gemini(
    model="gemini-2.0-flash-exp",
    api_key=os.getenv("GOOGLE_API_KEY")
)

MEMORI_API_KEY=your_key_here

from agno.memory.memori import Memori

memory = Memori(
    user_id="user_123",
    api_key=os.getenv("MEMORI_API_KEY")
)

QDRANT_URL=https://your-cluster.qdrant.io
QDRANT_API_KEY=your_key_here

import qdrant_client

client = qdrant_client.QdrantClient(
    url=os.getenv("QDRANT_URL"),
    api_key=os.getenv("QDRANT_API_KEY")
)

SERPAPI_API_KEY=your_key_here

from serpapi import GoogleSearch

search = GoogleSearch({
    "q": "AI agents",
    "api_key": os.getenv("SERPAPI_API_KEY")
})

results = search.get_dict()

TAVILY_API_KEY=tvly-your_key_here

from tavily import TavilyClient

client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))

results = client.search(
    query="Latest AI research",
    search_depth="advanced",
    max_results=5
)

SGAI_API_KEY=your_key_here

from agno.tools.scrapegraph import ScrapeGraphTools

tools = ScrapeGraphTools(api_key=os.getenv("SGAI_API_KEY"))

GITHUB_PERSONAL_ACCESS_TOKEN=ghp_your_token_here

async with MCPServerStdio(
    params={
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-github"],
        "env": {
            "GITHUB_PERSONAL_ACCESS_TOKEN": os.getenv("GITHUB_PERSONAL_ACCESS_TOKEN")
        }
    }
) as server:
    # Use GitHub MCP tools
    pass

SLACK_BOT_TOKEN=xoxb-your_token_here

CONTEXTUAL_API_KEY=your_key_here

ARIZE_PHOENIX_API_KEY=your_key_here

import os
from phoenix.otel import register

os.environ["PHOENIX_CLIENT_HEADERS"] = f"api_key={os.getenv('ARIZE_PHOENIX_API_KEY')}"
os.environ["PHOENIX_COLLECTOR_ENDPOINT"] = "https://app.phoenix.arize.com"

tracer_provider = register(
    project_name="my-project",
    auto_instrument=True
)

# ✅ Good: Use environment variables
import os
from dotenv import load_dotenv

load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")

# ❌ Bad: Hardcoded credentials
api_key = "sk-proj-abc123"  # NEVER DO THIS!

# ✅ Good: Check required keys
import os
from dotenv import load_dotenv

load_dotenv()

required_keys = [
    "NEBIUS_API_KEY",
    "OPENAI_API_KEY",
    "SERPAPI_API_KEY"
]

missing_keys = [
    key for key in required_keys
    if not os.getenv(key)
]

if missing_keys:
    raise ValueError(
        f"Missing required API keys: {', '.join(missing_keys)}"
    )

# ❌ Bad: Fail at runtime
# API call fails with cryptic error

# .env.example - Commit this to repo
NEBIUS_API_KEY=your_nebius_api_key_here
OPENAI_API_KEY=your_openai_key_here
SERPAPI_API_KEY=your_serpapi_key_here

# .env - Never commit this (add to .gitignore)
NEBIUS_API_KEY=actual_key_value
OPENAI_API_KEY=actual_key_value
SERPAPI_API_KEY=actual_key_value

# Track key age and rotation
import os
from datetime import datetime, timedelta

class APIKeyManager:
    def __init__(self):
        self.key_created_date = os.getenv("API_KEY_CREATED_DATE")
    
    def should_rotate(self, days: int = 90) -> bool:
        """Check if key is older than specified days."""
        if not self.key_created_date:
            return True
        
        created = datetime.fromisoformat(self.key_created_date)
        age = datetime.now() - created
        
        return age > timedelta(days=days)

# Add to .env
# API_KEY_CREATED_DATE=2024-01-15

# .env.development
NEBIUS_API_KEY=dev_key_here
OPENAI_API_KEY=dev_key_here

# .env.production
NEBIUS_API_KEY=prod_key_here
OPENAI_API_KEY=prod_key_here

# Load appropriate env file
import os
from dotenv import load_dotenv

env = os.getenv("ENVIRONMENT", "development")
load_dotenv(f".env.{env}")

import os
from openai import OpenAI

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Track token usage
response = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=[...]
)

print(f"Tokens used: {response.usage.total_tokens}")
print(f"Prompt tokens: {response.usage.prompt_tokens}")
print(f"Completion tokens: {response.usage.completion_tokens}")

# Calculate cost
PROMPT_COST_PER_1K = 0.01  # $0.01 per 1K tokens
COMPLETION_COST_PER_1K = 0.03  # $0.03 per 1K tokens

prompt_cost = (response.usage.prompt_tokens / 1000) * PROMPT_COST_PER_1K
completion_cost = (response.usage.completion_tokens / 1000) * COMPLETION_COST_PER_1K
total_cost = prompt_cost + completion_cost

print(f"Estimated cost: ${total_cost:.4f}")

class BudgetLimiter:
    def __init__(self, daily_limit: float = 10.0):
        self.daily_limit = daily_limit
        self.daily_spend = 0.0
        self.last_reset = datetime.now().date()
    
    def check_budget(self, estimated_cost: float) -> bool:
        """Check if request is within budget."""
        # Reset daily counter
        if datetime.now().date() > self.last_reset:
            self.daily_spend = 0.0
            self.last_reset = datetime.now().date()
        
        # Check limit
        if self.daily_spend + estimated_cost > self.daily_limit:
            raise ValueError(
                f"Daily budget exceeded: ${self.daily_spend:.2f}/${self.daily_limit:.2f}"
            )
        
        self.daily_spend += estimated_cost
        return True

# Usage
budget = BudgetLimiter(daily_limit=10.0)

if budget.check_budget(estimated_cost=0.05):
    response = client.chat.completions.create(...)