Why We Built AXIOM

from axiom_client import AxiomClient

axiom = AxiomClient("https://your-instance.com", "your-api-key")

# Step 1: Define categories with example texts
categories = {
    "sports": [
        "football match score",
        "basketball championship",
        "tennis tournament results",
    ],
    "technology": [
        "software development tools",
        "artificial intelligence research",
        "cloud computing infrastructure",
    ],
    "finance": [
        "stock market trading",
        "investment portfolio management",
        "cryptocurrency exchange rates",
    ],
}

# Step 2: Encode category prototypes
# (Each prototype is the "average" of its examples)
prototypes = {}
for category, examples in categories.items():
    batch = axiom.batch_encode(examples)
    # Store all example vectors for this category
    prototypes[category] = [v["vector"] for v in batch["vectors"]]

# Step 3: Classify new text
def classify(text: str) -> tuple[str, float]:
    """Classify text into the best matching category."""
    query_vec = axiom.encode(text)["vector"]

    best_category = ""
    best_score = 0.0

    for category, example_vecs in prototypes.items():
        # Average similarity across all examples in category
        scores = [axiom.similarity(query_vec, ev) for ev in example_vecs]
        avg_score = sum(scores) / len(scores)

        if avg_score > best_score:
            best_score = avg_score
            best_category = category

    return best_category, best_score

# Test
category, confidence = classify("new GPU released for gaming")
print(f"Category: {category}, Confidence: {confidence:.4f}")
# Output: Category: technology, Confidence: 0.5823

// FAQ Chatbot: match user questions to known answers

interface FAQ {
  question: string;
  answer: string;
  vector: number[];
}

const faqData = [
  { q: "How do I reset my password?", a: "Go to Settings > Security > Reset Password." },
  { q: "What payment methods do you accept?", a: "We accept Visa, Mastercard, and PayPal." },
  { q: "How do I cancel my subscription?", a: "Go to Settings > Billing > Cancel Plan." },
  { q: "What is your refund policy?", a: "Full refund within 30 days of purchase." },
  { q: "How do I contact support?", a: "Email support@example.com or use live chat." },
];

// Index: encode all FAQ questions
async function indexFAQs(): Promise<FAQ[]> {
  const batch = await fetch("/api/batch-encode", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ texts: faqData.map((f) => f.q) }),
  }).then((r) => r.json());

  return batch.vectors.map((v: any, i: number) => ({
    question: faqData[i].q,
    answer: faqData[i].a,
    vector: v.vector,
  }));
}

// Search: find best matching FAQ
async function findAnswer(userQuestion: string, faqs: FAQ[]): Promise<string> {
  const queryVec = await fetch("/api/encode", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ text: userQuestion }),
  }).then((r) => r.json());

  let bestMatch = { answer: "Sorry, I don't have an answer for that.", score: 0 };

  for (const faq of faqs) {
    const { similarity } = await fetch("/api/similarity", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ vector_a: queryVec.vector, vector_b: faq.vector }),
    }).then((r) => r.json());

    if (similarity > bestMatch.score) {
      bestMatch = { answer: faq.answer, score: similarity };
    }
  }

  // Only return answer if confidence is high enough
  if (bestMatch.score < 0.55) {
    return "I'm not sure about that. Please contact support.";
  }

  return bestMatch.answer;
}

// Usage
const faqs = await indexFAQs();
const answer = await findAnswer("how can I change my password?", faqs);
console.log(answer); // "Go to Settings > Security > Reset Password."

from axiom_client import AxiomClient

axiom = AxiomClient("https://your-instance.com", "your-api-key")

# Article database
articles = [
    {"id": 1, "title": "Introduction to Machine Learning", "content": "..."},
    {"id": 2, "title": "Deep Learning with PyTorch", "content": "..."},
    {"id": 3, "title": "Natural Language Processing Basics", "content": "..."},
    {"id": 4, "title": "Computer Vision with CNNs", "content": "..."},
    {"id": 5, "title": "Reinforcement Learning Explained", "content": "..."},
    {"id": 6, "title": "Web Development with React", "content": "..."},
    {"id": 7, "title": "Database Design Patterns", "content": "..."},
]

# Encode all article titles
batch = axiom.batch_encode([a["title"] for a in articles])
for i, v in enumerate(batch["vectors"]):
    articles[i]["vector"] = v["vector"]

def recommend(article_id: int, top_k: int = 3) -> list:
    """Recommend similar articles based on title similarity."""
    source = next(a for a in articles if a["id"] == article_id)

    results = []
    for article in articles:
        if article["id"] == article_id:
            continue
        sim = axiom.similarity(source["vector"], article["vector"])
        results.append({"title": article["title"], "score": sim})

    results.sort(key=lambda x: x["score"], reverse=True)
    return results[:top_k]

# "Readers who liked 'Introduction to Machine Learning' also liked:"
recs = recommend(1)
for r in recs:
    print(f"  {r['score']:.4f} | {r['title']}")
# Output:
#   0.6234 | Deep Learning with PyTorch
#   0.5891 | Reinforcement Learning Explained
#   0.5654 | Natural Language Processing Basics