FAQ

pip install modelred

uv add modelred

import os

# Debug: Print first few characters
api_key = os.environ.get("MODELRED_API_KEY", "")
print(f"Key starts with: {api_key[:5]}")  # Should be "mr_xx"

# Get some probe packs first
owned = client.list_owned_probes(page_size=5)
imported = client.list_imported_probes(page_size=5)

probe_ids = []
if owned.get("data"):
    probe_ids.append(owned["data"][0]["id"])
if imported.get("data"):
    probe_ids.append(imported["data"][0]["id"])

# Now create assessment
assessment = client.create_assessment_by_id(
    model_id="model_123",
    probe_pack_ids=probe_ids,  # At least one ID
    detector_provider="openai",
    detector_api_key="sk-...",
    detector_model="gpt-4o-mini",
)

assessment = client.get_assessment("assessment_id")

if assessment["status"] == "COMPLETED":
    results = assessment.get("results", {})
    print(results)
elif assessment["status"] == "FAILED":
    print(f"Assessment failed: {assessment.get('error')}")
else:
    print(f"Status: {assessment['status']}")  # QUEUED or RUNNING

# List your available packs
owned = client.list_owned_probes()
imported = client.list_imported_probes()

# Check if pack exists
print("Owned:", [p["id"] for p in owned["data"]])
print("Imported:", [p["id"] for p in imported["data"]])

owned = client.list_owned_probes()      # Your org's packs
imported = client.list_imported_probes()  # Imported public packs

models = client.list_models(status="inactive")
for model in models["data"]:
    print(f"Inactive: {model['displayName']}")
    # Update status in web UI

# ❌ Bad: Loads everything into memory
all_assessments = list(client.iter_assessments(page_size=50))

# ✅ Good: Process one at a time
for assessment in client.iter_assessments(page_size=50):
    process(assessment)  # Process and discard immediately

from unittest.mock import Mock
import pytest

@pytest.fixture
def mock_client():
    client = Mock()
    client.list_models.return_value = {
        "data": [{"id": "model_1", "displayName": "Test Model"}],
        "total": 1,
    }
    return client

def test_my_function(mock_client):
    result = my_function(mock_client)
    assert result is not None

# .env (add to .gitignore!)
MODELRED_API_KEY=mr_dev_key_here
OPENAI_API_KEY=sk_dev_key_here
ENV=development

from dotenv import load_dotenv
import os
from modelred import ModelRed

load_dotenv()

client = ModelRed(api_key=os.environ["MODELRED_API_KEY"])

import logging
import httpx

# Enable httpx debug logging
httpx_logger = logging.getLogger("httpx")
httpx_logger.setLevel(logging.DEBUG)

# Add handler
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter('%(name)s - %(levelname)s - %(message)s'))
httpx_logger.addHandler(handler)

# Now SDK requests will be logged
client = ModelRed(api_key="mr_...")
models = client.list_models()

import asyncio
from modelred import AsyncModelRed

async def main():
    async with AsyncModelRed(api_key="mr_...") as client:
        models = await client.list_models()
        # Use models here
    # client.aclose() called automatically

asyncio.run(main())

    while True:
        response = await client.list_models(page=page, page_size=50)
        all_models.extend(response["data"])

        if page >= response["totalPages"]:
            break
        page += 1

    return all_models

pip install --upgrade modelred

import modelred
print(modelred.__version__)

# ✅ Good: One client per thread
import threading

def worker():
    client = ModelRed(api_key=os.environ["MODELRED_API_KEY"])
    models = client.list_models()
    client.close()

threads = [threading.Thread(target=worker) for _ in range(5)]
for t in threads:
    t.start()
for t in threads:
    t.join()

import httpx
from modelred import ModelRed

transport = httpx.HTTPTransport(proxy="http://proxy.company.com:8080")
client = ModelRed(api_key="mr_...", transport=transport)