LangSmith Multi-Tenant: Separate Projects and API Keys

import httpx
import os

LANGSMITH_API_URL = "https://api.smith.langchain.com"
LANGSMITH_API_KEY = os.environ["LANGSMITH_ADMIN_API_KEY"]  # your root admin key

def create_tenant_project(tenant_id: str) -> dict:
    # Project name is deterministic — easy to look up later
    project_name = f"tenant-{tenant_id}"

    response = httpx.post(
        f"{LANGSMITH_API_URL}/api/v1/sessions",
        headers={"x-api-key": LANGSMITH_API_KEY},
        json={
            "name": project_name,
            "description": f"Traces for tenant {tenant_id}",
        },
    )
    response.raise_for_status()
    return response.json()  # includes "id" (project UUID)

project = create_tenant_project("acme-corp")
print(project["id"])  # store this in your tenant DB record

import httpx
import os

LANGSMITH_API_URL = "https://api.smith.langchain.com"
LANGSMITH_API_KEY = os.environ["LANGSMITH_ADMIN_API_KEY"]

def create_tenant_api_key(tenant_id: str) -> str:
    response = httpx.post(
        f"{LANGSMITH_API_URL}/api/v1/api-keys",
        headers={"x-api-key": LANGSMITH_API_KEY},
        json={
            "description": f"tenant-{tenant_id}",
        },
    )
    response.raise_for_status()
    data = response.json()
    # key is only returned once — store it encrypted immediately
    return data["key"]

tenant_key = create_tenant_api_key("acme-corp")
# store encrypted in your secrets manager (Vault, AWS Secrets Manager, etc.)

from langchain_core.tracers import LangChainTracer
from langchain_core.callbacks import CallbackManager
from langchain_openai import ChatOpenAI
import your_secrets_store  # your abstraction over Vault / AWS SM

def get_tenant_tracer(tenant_id: str) -> LangChainTracer:
    project_name = f"tenant-{tenant_id}"
    api_key = your_secrets_store.get(f"langsmith/tenant/{tenant_id}/api_key")

    return LangChainTracer(
        project_name=project_name,
        client=None,  # LangChainTracer builds its own client from the key below
    )

async def run_chain_for_tenant(tenant_id: str, user_input: str) -> str:
    api_key = your_secrets_store.get(f"langsmith/tenant/{tenant_id}/api_key")
    project_name = f"tenant-{tenant_id}"

    tracer = LangChainTracer(project_name=project_name)

    # Pass the tracer explicitly — no global state touched
    llm = ChatOpenAI(
        model="gpt-4o",
        callbacks=CallbackManager([tracer]),
    )

    # LANGCHAIN_API_KEY must be set per-client, not globally
    # Use langsmith.Client directly for full control
    from langsmith import Client
    ls_client = Client(api_key=api_key)
    tracer_explicit = LangChainTracer(
        project_name=project_name,
        client=ls_client,
    )

    llm_scoped = ChatOpenAI(
        model="gpt-4o",
        callbacks=CallbackManager([tracer_explicit]),
    )

    response = await llm_scoped.ainvoke(user_input)
    return response.content

import asyncio
from langsmith import Client
import your_secrets_store

async def smoke_test_isolation(tenant_a: str, tenant_b: str):
    # Run a chain for each tenant
    await run_chain_for_tenant(tenant_a, "Hello from tenant A")
    await run_chain_for_tenant(tenant_b, "Hello from tenant B")

    # Read traces back using each tenant's own key
    key_a = your_secrets_store.get(f"langsmith/tenant/{tenant_a}/api_key")
    key_b = your_secrets_store.get(f"langsmith/tenant/{tenant_b}/api_key")

    client_a = Client(api_key=key_a)
    client_b = Client(api_key=key_b)

    runs_a = list(client_a.list_runs(project_name=f"tenant-{tenant_a}", limit=5))
    runs_b = list(client_b.list_runs(project_name=f"tenant-{tenant_b}", limit=5))

    # Cross-check: tenant A's key should NOT read tenant B's project
    try:
        cross_runs = list(client_a.list_runs(project_name=f"tenant-{tenant_b}", limit=1))
        # In workspace-scoped keys, this will succeed — which is the known limitation
        # Mitigate by never exposing raw LangSmith keys to end-user tenants
        print(f"WARNING: cross-tenant read succeeded ({len(cross_runs)} runs)")
    except Exception as e:
        print(f"Cross-tenant read blocked: {e}")

    print(f"Tenant A runs: {len(runs_a)}")
    print(f"Tenant B runs: {len(runs_b)}")

asyncio.run(smoke_test_isolation("acme-corp", "beta-inc"))

import httpx

async def rotate_tenant_key(tenant_id: str) -> None:
    admin_key = os.environ["LANGSMITH_ADMIN_API_KEY"]
    headers = {"x-api-key": admin_key}

    # 1. Create new key first (never leave a gap)
    create_resp = httpx.post(
        f"{LANGSMITH_API_URL}/api/v1/api-keys",
        headers=headers,
        json={"description": f"tenant-{tenant_id}-rotated"},
    )
    create_resp.raise_for_status()
    new_key = create_resp.json()["key"]
    new_key_id = create_resp.json()["id"]

    # 2. Fetch old key ID from your store before overwriting
    old_key_id = your_secrets_store.get(f"langsmith/tenant/{tenant_id}/key_id")

    # 3. Write new key to secrets store (atomic swap)
    your_secrets_store.set(f"langsmith/tenant/{tenant_id}/api_key", new_key)
    your_secrets_store.set(f"langsmith/tenant/{tenant_id}/key_id", new_key_id)

    # 4. Delete old key — safe after store is updated
    if old_key_id:
        delete_resp = httpx.delete(
            f"{LANGSMITH_API_URL}/api/v1/api-keys/{old_key_id}",
            headers=headers,
        )
        delete_resp.raise_for_status()

    print(f"Rotated key for tenant {tenant_id}")

# List all tenant projects via admin key
curl https://api.smith.langchain.com/api/v1/sessions \
  -H "x-api-key: $LANGSMITH_ADMIN_API_KEY" \
  | jq '[.[] | select(.name | startswith("tenant-")) | {name, id}]'

[
  {"name": "tenant-acme-corp", "id": "3f2a1b..."},
  {"name": "tenant-beta-inc",  "id": "9c7d4e..."}
]