Answer from your content with Grounded Responses

curl -X POST 'https://platform.ai.gloo.com/ai/v1/grounded/responses' \
  -H "Authorization: Bearer $GLOO_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "gloo-anthropic-claude-sonnet-4.6",
    "input": [{ "role": "user", "content": "What resources do you have on family counseling?" }],
    "rag_publisher": "'"$GLOO_PUBLISHER"'",
    "sources_limit": 3
  }'

import os
import requests

API_KEY = os.environ["GLOO_API_KEY"]
PUBLISHER = os.environ["GLOO_PUBLISHER"]
GROUNDED_URL = "https://platform.ai.gloo.com/ai/v1/grounded/responses"
MODEL = "gloo-anthropic-claude-sonnet-4.6"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}


def output_text(response: dict) -> str:
    """Join the text of every message item in output[]."""
    return "".join(
        part.get("text", "")
        for item in response.get("output", [])
        if item.get("type") == "message"
        for part in item.get("content", [])
        if part.get("type") == "output_text"
    )


r = requests.post(GROUNDED_URL, headers=HEADERS, json={
    "model": MODEL,
    "input": [{"role": "user", "content": "What resources do you have on family counseling?"}],
    "rag_publisher": PUBLISHER,
    "sources_limit": 3,
}, timeout=120)
r.raise_for_status()
result = r.json()

print("Grounded:", result["sources_returned"])
print(output_text(result))

const API_KEY = process.env.GLOO_API_KEY!;
const PUBLISHER = process.env.GLOO_PUBLISHER!;
const GROUNDED_URL = "https://platform.ai.gloo.com/ai/v1/grounded/responses";
const MODEL = "gloo-anthropic-claude-sonnet-4.6";
const HEADERS = { Authorization: `Bearer ${API_KEY}`, "Content-Type": "application/json" };

/** Join the text of every message item in output[]. */
function outputText(response: any): string {
  return (response.output ?? [])
    .filter((item: any) => item.type === "message")
    .flatMap((item: any) => item.content ?? [])
    .filter((part: any) => part.type === "output_text")
    .map((part: any) => part.text ?? "")
    .join("");
}

const res = await fetch(GROUNDED_URL, {
  method: "POST",
  headers: HEADERS,
  body: JSON.stringify({
    model: MODEL,
    input: [{ role: "user", content: "What resources do you have on family counseling?" }],
    rag_publisher: PUBLISHER,
    sources_limit: 3,
  }),
});
if (!res.ok) throw new Error(`Request failed: ${res.status} ${await res.text()}`);
const result = await res.json();

console.log("Grounded:", result.sources_returned);
console.log(outputText(result));

INSTRUCTIONS = """Answer only from the provided sources. Do not add outside knowledge, even if it is correct.
Put quotation marks only around wording copied exactly from a source; label paraphrase as paraphrase.
If the sources don't answer the question, say so plainly instead of guessing.
If the question assumes something the sources don't support, correct that first."""

const INSTRUCTIONS = `Answer only from the provided sources. Do not add outside knowledge, even if it is correct.
Put quotation marks only around wording copied exactly from a source; label paraphrase as paraphrase.
If the sources don't answer the question, say so plainly instead of guessing.
If the question assumes something the sources don't support, correct that first.`;

NO_SOURCES = "I couldn't find that in our resources. Try rephrasing, or ask about a topic we cover."


def grounded(question: str, sources_limit: int = 5) -> dict:
    r = requests.post(GROUNDED_URL, headers=HEADERS, json={
        "model": MODEL,
        "instructions": INSTRUCTIONS,
        "input": [{"role": "user", "content": question}],
        "rag_publisher": PUBLISHER,
        "sources_limit": sources_limit,
    }, timeout=120)
    r.raise_for_status()
    return r.json()


result = grounded("What's the capital of Mongolia?")  # probably not in your content
if not result["sources_returned"]:
    print(NO_SOURCES)  # or show the answer clearly labeled as not from your content
else:
    print(output_text(result))

const NO_SOURCES =
  "I couldn't find that in our resources. Try rephrasing, or ask about a topic we cover.";

async function grounded(question: string, sourcesLimit = 5): Promise<any> {
  const res = await fetch(GROUNDED_URL, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify({
      model: MODEL,
      instructions: INSTRUCTIONS,
      input: [{ role: "user", content: question }],
      rag_publisher: PUBLISHER,
      sources_limit: sourcesLimit,
    }),
  });
  if (!res.ok) throw new Error(`Request failed: ${res.status} ${await res.text()}`);
  return res.json();
}

const result = await grounded("What's the capital of Mongolia?"); // probably not in your content
console.log(result.sources_returned ? outputText(result) : NO_SOURCES);

import re

SEARCH_URL = "https://platform.ai.gloo.com/ai/v1/data/search"
TENANT = "".join(PUBLISHER.split())  # remove all whitespace

_QUOTED = re.compile(r'"([^"]*)"|“([^”]*)”')  # straight and curly quotes each close their own kind
_EDGE = " .,;:!?"


def quoted_spans(text: str, min_length: int = 12) -> list[str]:
    """Quoted spans, paired in order; by default short ones such as a single quoted word are skipped."""
    spans = [straight or curly for straight, curly in _QUOTED.findall(text)]
    return [span for span in spans if len(span) >= min_length]


def balanced_quotes(text: str) -> bool:
    """True when every opening quote mark has a closing one."""
    depth = 0  # each curly closing mark must follow an opening one
    for ch in text:
        if ch == "“":
            depth += 1
        elif ch == "”":
            depth -= 1
            if depth < 0:
                return False
    return depth == 0 and text.count('"') % 2 == 0


def search_passages(question: str, limit: int = 10) -> list[dict]:
    r = requests.post(SEARCH_URL, headers=HEADERS, json={
        "query": question, "collection": "GlooProd", "tenant": TENANT,
        "certainty": 0.5, "limit": limit,
    }, timeout=60)
    r.raise_for_status()
    return [hit["properties"] for hit in r.json().get("data", [])]


def normalize(text: str) -> str:
    text = text.replace("’", "'").replace("‘", "'").replace("“", '"').replace("”", '"')
    return re.sub(r"\s+", " ", text.replace("…", "...")).strip().lower()


def unverified_quotes(answer: str, sources: list[str]) -> list[str]:
    """Quoted spans in `answer` that no single source contains."""
    normalized = [normalize(s) for s in sources]
    missing = []
    for span in quoted_spans(answer):
        parts = [p for p in (p.strip(_EDGE) for p in normalize(span).split("...")) if p]
        if not parts or not any(all(p in src for p in parts) for src in normalized):
            missing.append(span)
    return missing

const SEARCH_URL = "https://platform.ai.gloo.com/ai/v1/data/search";
const TENANT = PUBLISHER.replace(/\s+/g, "");

const QUOTED = /"([^"]*)"|“([^”]*)”/g; // straight and curly quotes each close their own kind
const EDGE = /^[\s.,;:!?]+|[\s.,;:!?]+$/g;

/** Quoted spans, paired in order; by default short ones such as a single quoted word are skipped. */
function quotedSpans(text: string, minLength = 12): string[] {
  const spans = [...text.matchAll(QUOTED)].map((m) => m[1] ?? m[2]);
  return spans.filter((span) => span.length >= minLength);
}

/** True when every opening quote mark has a closing one. */
function balancedQuotes(text: string): boolean {
  let depth = 0; // each curly closing mark must follow an opening one
  for (const ch of text) {
    if (ch === "“") depth += 1;
    else if (ch === "”" && --depth < 0) return false;
  }
  return depth === 0 && (text.match(/"/g) ?? []).length % 2 === 0;
}

async function searchPassages(question: string, limit = 10): Promise<any[]> {
  const res = await fetch(SEARCH_URL, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify({ query: question, collection: "GlooProd", tenant: TENANT, certainty: 0.5, limit }),
  });
  if (!res.ok) throw new Error(`Search failed: ${res.status} ${await res.text()}`);
  return ((await res.json()).data ?? []).map((hit: any) => hit.properties);
}

function normalize(text: string): string {
  return text.replace(/[‘’]/g, "'").replace(/[“”]/g, '"').replace(/…/g, "...")
    .replace(/\s+/g, " ").trim().toLowerCase();
}

/** Quoted spans in `answer` that no single source contains. */
function unverifiedQuotes(answer: string, sources: string[]): string[] {
  const normalized = sources.map(normalize);
  const missing: string[] = [];
  for (const span of quotedSpans(answer)) {
    const parts = normalize(span).split("...").map((p) => p.replace(EDGE, "")).filter(Boolean);
    const ok = parts.length > 0 && normalized.some((src) => parts.every((p) => src.includes(p)));
    if (!ok) missing.push(span);
  }
  return missing;
}

import json

with requests.post(GROUNDED_URL, headers=HEADERS, stream=True, timeout=300, json={
    "model": MODEL, "instructions": INSTRUCTIONS, "stream": True,
    "input": [{"role": "user", "content": "How do we sign up to volunteer?"}],
    "rag_publisher": PUBLISHER,
}) as r:
    r.raise_for_status()
    if r.headers.get("X-Sources-Returned", "").lower() != "true":
        print(NO_SOURCES)
    else:
        r.encoding = "utf-8"  # SSE is always UTF-8; don't guess from the header
        event, parts = None, []
        for line in r.iter_lines(decode_unicode=True):
            if line.startswith("event:"):
                event = line[len("event:"):].strip()
            elif line.startswith("data:"):
                data = json.loads(line[len("data:"):].strip())
                if event == "response.output_text.delta":
                    parts.append(data["delta"])  # buffer, then verify before showing
                elif event == "response.failed" or (event and not event.startswith("response.")):
                    raise RuntimeError(f"Stream ended with {event}: {data}")
        print("".join(parts))

const res = await fetch(GROUNDED_URL, {
  method: "POST",
  headers: HEADERS,
  body: JSON.stringify({
    model: MODEL, instructions: INSTRUCTIONS, stream: true,
    input: [{ role: "user", content: "How do we sign up to volunteer?" }],
    rag_publisher: PUBLISHER,
  }),
});
if (!res.ok) throw new Error(`Request failed: ${res.status} ${await res.text()}`);

if ((res.headers.get("X-Sources-Returned") ?? "").toLowerCase() !== "true") {
  console.log(NO_SOURCES);
} else {
  const reader = res.body!.getReader();
  const decoder = new TextDecoder();
  const parts: string[] = [];
  let buffer = "";
  let event: string | null = null;
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split("\n");
    buffer = lines.pop() ?? "";
    for (const line of lines.map((l) => l.trim())) {
      if (line.startsWith("event:")) event = line.slice(6).trim();
      else if (line.startsWith("data:")) {
        const data = JSON.parse(line.slice(5).trim());
        if (event === "response.output_text.delta") parts.push(data.delta); // buffer, then verify
        else if (event === "response.failed" || (event && !event.startsWith("response."))) {
          throw new Error(`Stream ended with ${event}: ${JSON.stringify(data)}`);
        }
      }
    }
  }
  console.log(parts.join(""));
}

def answer(question: str) -> dict:
    """Returns {"status": "verified" | "unverified" | "ungrounded" | "unsupported", ...}.
    Show "verified" and "unverified" with their sources; only "verified" had quotations checked."""
    unverified: list[str] = []

    for sources_limit in (5, 10):  # one escalation, not a loop
        result = grounded(question, sources_limit=sources_limit)
        # Check grounding first: with no sources there is nothing to verify against.
        if not result["sources_returned"]:
            return {"status": "ungrounded", "message": NO_SOURCES}

        passages = search_passages(question, limit=sources_limit * 2)
        sources = [p.get("snippet", "") for p in passages]
        text = output_text(result)
        unverified = unverified_quotes(text, sources)
        if not unverified:
            # Verified only when every quotation was closed, long enough to check, and checked out.
            spans = quoted_spans(text)
            checked = (bool(passages) and bool(spans) and balanced_quotes(text)
                       and len(spans) == len(quoted_spans(text, 1)))
            return {
                "status": "verified" if checked else "unverified",
                "text": text,
                "sources": [{"title": p.get("item_title"), "url": p.get("item_url") or None,
                             "excerpt": p.get("snippet", "")[:200]} for p in passages],
            }

    return {"status": "unsupported", "unverified": unverified,
            "message": "I couldn't confirm that from our resources."}


if __name__ == "__main__":
    reply = answer("What resources do you have on family counseling?")
    if reply["status"] in ("verified", "unverified"):
        print(reply["text"], "\n\nSources:")
        for s in reply["sources"]:
            print(f'- {s["title"]}' + (f' ({s["url"]})' if s["url"] else ""))
    else:
        print(reply["message"])

type Answer =
  | {
      status: "verified" | "unverified";
      text: string;
      sources: { title: string; url: string | null; excerpt: string }[];
    }
  | { status: "ungrounded" | "unsupported"; message: string; unverified?: string[] };

/** Show "verified" and "unverified" with their sources; only "verified" had quotations checked. */
async function answer(question: string): Promise<Answer> {
  let unverified: string[] = [];

  for (const sourcesLimit of [5, 10]) { // one escalation, not a loop
    const result = await grounded(question, sourcesLimit);
    // Check grounding first: with no sources there is nothing to verify against.
    if (!result.sources_returned) return { status: "ungrounded", message: NO_SOURCES };

    const passages = await searchPassages(question, sourcesLimit * 2);
    const sources = passages.map((p) => p.snippet ?? "");
    const text = outputText(result);
    unverified = unverifiedQuotes(text, sources);
    if (unverified.length === 0) {
      // Verified only when every quotation was closed, long enough to check, and checked out.
      const spans = quotedSpans(text);
      const checked = passages.length > 0 && spans.length > 0 && balancedQuotes(text)
        && spans.length === quotedSpans(text, 1).length;
      return {
        status: checked ? "verified" : "unverified",
        text,
        sources: passages.map((p) => ({
          title: p.item_title, url: p.item_url || null, excerpt: (p.snippet ?? "").slice(0, 200),
        })),
      };
    }
  }
  return { status: "unsupported", unverified, message: "I couldn't confirm that from our resources." };
}

async function main() {
  const reply = await answer("What resources do you have on family counseling?");
  if ("text" in reply) { // "verified" or "unverified"
    console.log(reply.text, "\n\nSources:");
    for (const s of reply.sources) console.log(`- ${s.title}${s.url ? ` (${s.url})` : ""}`);
  } else {
    console.log(reply.message);
  }
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});