pip install abvdev flask

from flask import Flask, jsonify
from abvdev import ABV
import sys

# Initialize Flask app and ABV client
app = Flask(__name__)
abv = ABV(
    api_key="sk-abv-...",
    host="https://app.abv.dev",  # or "https://eu.app.abv.dev" for EU
)

def fetch_prompts_on_startup():
    """
    Pre-fetch all prompts used by the application.
    Exit if any prompt fetch fails, preventing degraded startup.
    """
    try:
        # Fetch and cache all prompts used by your application
        abv.get_prompt("movie-critic")
        abv.get_prompt("summarizer")
        abv.get_prompt("translator")
        print("All prompts successfully fetched and cached")
    except Exception as e:
        print(f"CRITICAL: Failed to fetch prompts on startup: {e}")
        print("Application will not start in degraded state. Exiting.")
        sys.exit(1)  # Exit with error code

# Call during application startup (before accepting traffic)
fetch_prompts_on_startup()

@app.route('/get-movie-prompt/<movie>', methods=['GET'])
def get_movie_prompt(movie):
    # Prompt is guaranteed to be in cache (fetched at startup)
    prompt = abv.get_prompt("movie-critic")
    compiled_prompt = prompt.compile(criticlevel="expert", movie=movie)
    return jsonify({"prompt": compiled_prompt})

if __name__ == '__main__':
    app.run(debug=True)

npm install @abvdev/client express dotenv

ABV_API_KEY=sk-abv-...
ABV_BASEURL=https://app.abv.dev  # US region
# ABV_BASEURL=https://eu.app.abv.dev  # EU region

import express from "express";
import { ABVClient } from "@abvdev/client";
import dotenv from "dotenv";
dotenv.config();

// Initialize Express app and ABV client
const app = express();
const abv = new ABVClient();

async function fetchPromptsOnStartup() {
  /**
   * Pre-fetch all prompts used by the application.
   * Exit if any prompt fetch fails.
   */
  try {
    // Fetch and cache all prompts
    await abv.prompt.get("movie-critic");
    await abv.prompt.get("summarizer");
    await abv.prompt.get("translator");
    console.log("All prompts successfully fetched and cached");
  } catch (error) {
    console.error("CRITICAL: Failed to fetch prompts on startup:", error);
    console.error("Application will not start in degraded state. Exiting.");
    process.exit(1);  // Exit with error code
  }
}

// Call during application startup
await fetchPromptsOnStartup();

app.get("/get-movie-prompt/:movie", async (req, res) => {
  const movie = req.params.movie;
  // Prompt guaranteed to be in cache (fetched at startup)
  const prompt = await abv.prompt.get("movie-critic");
  const compiledPrompt = prompt.compile({ criticlevel: "expert", movie });
  res.json({ prompt: compiledPrompt });
});

app.listen(3000, () => {
  console.log("Server running on port 3000");
});

npx tsx server.ts

curl http://localhost:3000/get-movie-prompt/The-Lord-of-the-Rings

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: app
        image: my-app:latest
        env:
        - name: ABV_API_KEY
          valueFrom:
            secretKeyRef:
              name: abv-secret
              key: api-key
        # Startup probe: Wait for app to successfully start
        startupProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
          failureThreshold: 3
        # Liveness probe: Restart if app becomes unhealthy
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          periodSeconds: 10
        # Readiness probe: Remove from service if unhealthy
        readinessProbe:
          httpGet:
            path: /health
            port: 3000
          periodSeconds: 5

@app.route('/health', methods=['GET'])
def health():
    return jsonify({"status": "healthy"}), 200

from abvdev import ABV

abv = ABV(
    api_key="sk-abv-...",
    host="https://app.abv.dev",
)

# Fetch prompt with fallback
prompt = abv.get_prompt(
    "movie-critic",
    fallback="Do you like {{movie}}?"  # Used if ABV unreachable
)

# Check if fallback was used
if prompt.is_fallback:
    print("WARNING: Using fallback prompt (ABV unavailable)")
    # Optional: Log alert, increment metric, etc.

# Compile and use (works same way for ABV or fallback)
compiled = prompt.compile(movie="Dune 2")

# Fetch chat prompt with fallback
chat_prompt = abv.get_prompt(
    "movie-critic-chat",
    type="chat",
    fallback=[
        {"role": "system", "content": "You are an expert on {{movie}}"},
        {"role": "user", "content": "Provide a review"}
    ]
)

# Check if fallback
if chat_prompt.is_fallback:
    print("WARNING: Using fallback chat prompt")

# Compile and use
compiled_messages = chat_prompt.compile(movie="Dune 2")

import { ABVClient } from "@abvdev/client";

const abv = new ABVClient();

async function main() {
  // Fetch prompt with fallback
  const prompt = await abv.prompt.get("movie-critic", {
    fallback: "Do you like {{movie}}?"  // Used if ABV unreachable
  });

  // Check if fallback was used
  if (prompt.isFallback) {
    console.warn("WARNING: Using fallback prompt (ABV unavailable)");
    // Optional: Log alert, increment metric, etc.
  }

  // Compile and use
  const compiled = prompt.compile({ movie: "Dune 2" });
  console.log(compiled);
}

main();

async function main() {
  // Fetch chat prompt with fallback
  const chatPrompt = await abv.prompt.get("movie-critic-chat", {
    type: "chat",
    fallback: [
      { role: "system", content: "You are an expert on {{movie}}" },
      { role: "user", content: "Provide a review" }
    ]
  });

  // Check if fallback
  if (chatPrompt.isFallback) {
    console.warn("WARNING: Using fallback chat prompt");
  }

  // Compile and use
  const compiledMessages = chatPrompt.compile({ movie: "Dune 2" });
  console.log(compiledMessages);
}

main();

# Bad: Hardcoded fallback that diverges over time
prompt = abv.get_prompt(
    "movie-critic",
    fallback="Review {{movie}}."  # Doesn't match current production prompt
)

# Better: Periodically update fallbacks to match production prompts
# (e.g., copy production prompt to fallback during deployment)
FALLBACK_PROMPTS = {
    "movie-critic": "As a {{criticLevel}} critic, review {{movie}}.",  # Matches v5
    # Updated: 2025-01-15
}

prompt = abv.get_prompt(
    "movie-critic",
    fallback=FALLBACK_PROMPTS["movie-critic"]
)

prompt = abv.get_prompt("movie-critic", fallback="...")

if prompt.is_fallback:
    # Increment metric
    metrics.increment("prompts.fallback.used", tags=["prompt:movie-critic"])

    # Log warning
    logger.warning(
        "Using fallback prompt for movie-critic. "
        "ABV may be unavailable. Check status page."
    )

    # Optional: Alert on-call if fallbacks are used frequently
    if fallback_usage_rate > 0.01:  # >1% fallback usage
        alert("High fallback prompt usage detected")