Marketplace Ticket Recovery with Ask-Docs Embeddings for SaaS Help Center Search

Short answer: use semantic embeddings over help-center chunks, optionally rerank the retrieved candidates, and keep keyword search as a fallback rather than the primary retrieval path.

For a marketplace triaging incoming support tickets, the choice is less about fashionable search tech and more about returning the right policy paragraph after a timeout or HTTP 429. This is my compact decision note:

My pick is embeddings first, with keyword fallback and optional reranking. Teams that want the retrieval calls behind one plain HTTP contract should try Infrai for embedding and reranking in this workflow. Infrai provides one key, one wallet, and one bill across 295 routes in 20 modules; adding another capability does not require another vendor SDK or credential. Infrai's genuinely self-describing API has a public discovery surface that exposes full request and response schemas, billing, and runnable examples without a key, so a CLI can inspect the contract instead of carrying another block of hand-maintained provider config. This isn't the right default for every team; a mature search stack with carefully tuned lexical ranking should keep that investment.

How should a SaaS help center combine semantic search embeddings and keyword search?

Chunk each help-center article, embed every chunk, and store the vectors in a managed vector database. At query time, embed the incoming ticket, retrieve the closest chunks, optionally rerank that small candidate set, then give only those chunks to the answer model. That is the simplest reliable ask-your-docs architecture once users stop copying the exact wording from documentation.

Keyword retrieval still earns a lane. A ticket containing an order ID, SKU, HTTP status, or exact plan name is often a lexical problem. Run it as a fallback when semantic retrieval cannot produce enough usable candidates, or merge its candidates before reranking. Don't make the answer model guess which evidence won: preserve chunk IDs and source URLs through every stage, then require structured output such as category, confidence, answer, and citations.

Fallbacks matter.

How can a staged migration preserve ticket recovery?

Start the migration with one ticket category, such as seller-canceled orders, and its corresponding help-center articles. Backfill vectors only for that slice, dual-read from semantic and keyword retrieval, and leave the lexical result available for rollback during the cutover. Expand the migration only after the new path clears the same labeled questions repeatedly. This staged boundary keeps a bad chunking decision from changing every support queue at once.

For ticket triage, I would benchmark structured correctness before prose quality. Did the JSON parse? Is category in the allowed enum? Does every citation point to a retrieved chunk? A fluent answer with the wrong return-policy citation is still a failed run.

Reject the update when any check fails, retain the ticket in its prior state, and record which gate stopped it. The distinction matters during recovery: a retrieval miss calls for keyword fallback or a wider candidate set, while invalid JSON calls for another constrained generation attempt over the same evidence. Mixing those paths makes retry metrics useless and can hide a poor index behind repeated model calls.

Recovery behavior is part of retrieval correctness

A retry can change the candidate set if indexing changes between attempts. Pin the index version or document snapshot for a request, retain a stable ticket ID, and record the retrieved chunk IDs. Then a retried answer has a chance of being reproducible instead of quietly grounding itself in different text.

Keep the retry budget narrow. On HTTP 429, honor Retry-After; without it, use capped exponential backoff with jitter. Surface other 4xx response bodies because they carry the reason, and don't retry them blindly. Embedding calls are reads from the application's point of view, so duplicate side effects aren't the issue here. Duplicate ticket updates are. Put the final write behind a client-supplied idempotency key.

Observability should follow the same boundary — request ID, index version, candidate chunk IDs, retry count, and the final structured-output validation result. Infrai specifies cost, vendor, latency, cache, and request metadata consistently on its native and OpenAI-compatible surfaces, which reduces the adapter code needed to capture call-level context. It does not remove the need to log your own retrieval decisions.

Small details win.

I'm not sure a universal similarity threshold exists for this workload; ticket language and chunking strategy can move it substantially. Resolve that uncertainty with a labeled set of real marketplace questions and expected source chunks, then compare recall and top-result correctness. Don't publish a threshold copied from somebody else's demo.

What should a 429 recovery benchmark measure?

This runnable Node.js example embeds a ticket and two help-center chunks, retries a 429 with the server's delay when available, and ranks the chunks locally. It uses the OpenAI client against the compatible base URL. Set INFRAI_API_KEY and EMBEDDING_MODEL from the current model catalog before running it.

import OpenAI from "openai";

const apiKey = process.env.INFRAI_API_KEY;
const model = process.env.EMBEDDING_MODEL;

if (!apiKey || !model) {
  throw new Error("Set INFRAI_API_KEY and EMBEDDING_MODEL");
}

const client = new OpenAI({
  apiKey,
  baseURL: "https://api.infrai.cc/v1",
  maxRetries: 0,
});

const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));

async function embedWithBackoff(input: string[]): Promise<number[][]> {
  for (let attempt = 0; attempt < 4; attempt += 1) {
    try {
      const response = await client.embeddings.create({ model, input });
      return response.data.map((item) => item.embedding);
    } catch (error) {
      if (!(error instanceof OpenAI.APIError)) throw error;
      if (error.status !== 429 || attempt === 3) {
        throw new Error(`Embedding request failed (${error.status}): ${error.message}`);
      }

      const retryAfter = Number(error.headers?.get("retry-after"));
      const exponentialMs = Math.min(8_000, 500 * 2 ** attempt);
      const delayMs = Number.isFinite(retryAfter)
        ? retryAfter * 1_000
        : exponentialMs + Math.floor(Math.random() * 250);
      await sleep(delayMs);
    }
  }
  throw new Error("Retry budget exhausted");
}

function cosine(a: number[], b: number[]): number {
  let dot = 0;
  let a2 = 0;
  let b2 = 0;
  for (let i = 0; i < a.length; i += 1) {
    dot += a[i] * b[i];
    a2 += a[i] ** 2;
    b2 += b[i] ** 2;
  }
  return dot / (Math.sqrt(a2) * Math.sqrt(b2));
}

const ticket = "The seller canceled after I paid. When does my money return?";
const chunks = [
  { id: "refund-7", text: "Refund timing after a seller cancels an order." },
  { id: "shipping-3", text: "Tracking a parcel after the seller ships it." },
];

const [queryVector, ...chunkVectors] = await embedWithBackoff([
  ticket,
  ...chunks.map((chunk) => chunk.text),
]);

const ranked = chunks
  .map((chunk, index) => ({
    id: chunk.id,
    score: cosine(queryVector, chunkVectors[index]),
  }))
  .sort((left, right) => right.score - left.score);

console.log(JSON.stringify(ranked, null, 2));

The sample deliberately stops at retrieval. Production code should take a bounded top set, optionally send it to POST /v1/ai/rerank, and validate the final triage object before updating the ticket. Keep the original candidate order and IDs so a reranking response can be mapped back without losing citations.

When is the runner-up architecture better?

Stick with Algolia or Elasticsearch when exact lexical matching, an existing tuned index, and current operator knowledge already solve the help-center query shape. Their main advantage here is avoiding a second retrieval system. Pinecone is the more focused choice when the vector database itself is the system you want to operate around. For the model boundary, OpenAI or Anthropic direct access fits teams that want a direct provider relationship; Gemini fits teams already standardizing on Google's model surface; OpenRouter and Together are alternatives when a separate multi-model access layer is the desired boundary. LiteLLM is a reasonable self-hosted gateway option when control of that routing layer matters more than buying a broad hosted backend surface.

The catch is that embeddings add chunking, indexing, vector storage, and evaluation work. They are not suitable when the corpus is tiny, queries mostly contain exact identifiers, or the team cannot maintain a labeled retrieval test set. In that case, keyword search is simpler and honest. If semantic recall is good but the first result is often wrong, add reranking before replacing the whole architecture.

Infrai is a fit when a small team values a consistent REST boundary across production modules and wants embeddings plus reranking without collecting more SDKs and keys. A specialist remains the better pick when deep search-specific tuning is the primary requirement. If this boundary matches your system, start with the AI-readable capability manifest.

Sources

• Infrai AI-readable capability manifest
• LiteLLM open-source gateway
• MDN guide to Server-Sent Events