Reliability and Grounding

result = await rag.completion("Who founded Acme Corp?")

print(result.answer)
print(result.metadata["num_context_items"])  # how many context sections were sent
print(result.metadata["strategy"])           # e.g. "MultiPathRetrieval"
print(result.metadata["retrieval_query"])    # the query actually used for retrieval

Document ──PART_OF──▶ Chunk ──NEXT_CHUNK──▶ Chunk
                        ▲
                        │ MENTIONED_IN
                        │
                   __Entity__ ──RELATES──▶ __Entity__

await rag.ingest(text=article_text, document_id="kb/acme-corp-history")

from graphrag_sdk import ConnectionConfig, FalkorDBConnection, GraphStore, VectorStore
from graphrag_sdk.retrieval.strategies.local import LocalRetrieval

connection = FalkorDBConnection(ConnectionConfig(host="localhost", graph_name="my_graph"))
graph = GraphStore(connection)

retrieved = await rag.retrieve(
    "What did Professor Harmon discover?",
    strategy=LocalRetrieval(
        graph_store=graph,
        vector_store=VectorStore(connection, embedder=embedder, embedding_dimension=256),
        embedder=embedder,
        top_k=5,
    ),
)

for item in retrieved.items:
    chunk_id = item.metadata.get("chunk_id")
    if chunk_id is None:
        continue
    evidence = await graph.query_raw(
        "MATCH (d:Document)-[:PART_OF]->(c:Chunk {id: $chunk_id}) "
        "RETURN d.id AS document_id, d.path AS path, c.index AS chunk_index",
        {"chunk_id": chunk_id},
    )
    print(evidence.result_set)

mentions = await graph.query_raw(
    "MATCH (e:__Entity__ {name: $name})-[:MENTIONED_IN]->(c:Chunk)"
    "<-[:PART_OF]-(d:Document) "
    "RETURN d.path AS source, c.id AS chunk_id, c.text AS text LIMIT 10",
    {"name": "Acme Corp"},
)

from graphrag_sdk import GraphStore, MultiPathRetrieval, VectorStore

strategy = MultiPathRetrieval(
    graph_store=GraphStore(connection),
    vector_store=VectorStore(connection, embedder=embedder, embedding_dimension=256),
    embedder=embedder,
    llm=llm,
    chunk_top_k=15,        # passages kept after reranking
    max_entities=30,       # entities carried into relationship expansion
    max_relationships=20,  # cap on expanded RELATES edges
    rel_top_k=15,          # RELATES edge vector search results
    enable_cypher=True,    # opt-in graph query path
    # Required: a strategy you construct yourself never receives the ontology.
    # GraphRAG only injects it into its own default strategy, so text-to-Cypher
    # would otherwise generate against an empty schema.
    ontology=await rag.get_ontology(),
)

result = await rag.completion("How is Acme Corp connected to Initech?", strategy=strategy)

from graphrag_sdk import CosineReranker

reranker = CosineReranker(embedder=embedder, top_k=10)
retrieved = await rag.retrieve("Where is Acme Corp headquartered?", reranker=reranker)

for item in retrieved.items:
    print(round(item.score, 3), item.metadata.get("section"), item.content[:80])

from graphrag_sdk import CosineReranker

MIN_SCORE = 0.35
MIN_ITEMS = 2

reranker = CosineReranker(embedder=embedder, top_k=10)
retrieved = await rag.retrieve(question, reranker=reranker)

strong = [item for item in retrieved.items if (item.score or 0.0) >= MIN_SCORE]

if len(strong) < MIN_ITEMS:
    answer = "I don't have enough information in the knowledge base to answer that."
else:
    result = await rag.completion(question, reranker=reranker, return_context=True)
    answer = result.answer

ABSTAIN_TEMPLATE = (
    "<context>\n{context}\n</context>\n\n"
    "Answer the question using only the context above. "
    "If the context does not contain the answer, reply exactly with "
    "INSUFFICIENT_CONTEXT and nothing else.\n\n"
    "Question: {question}\n\nAnswer:"
)

result = await rag.completion(question, prompt_template=ABSTAIN_TEMPLATE)
if result.answer.strip() == "INSUFFICIENT_CONTEXT":
    ...

result = await rag.completion(question, return_context=True)

evidence = "\n---\n".join(item.content for item in result.retriever_result.items)

verdict = await rag.llm.ainvoke(
    "Evidence:\n" + evidence
    + "\n\nAnswer:\n" + result.answer
    + "\n\nList any statement in the answer that is not supported by the "
    "evidence. Reply SUPPORTED if every statement is backed."
)
print(verdict.content)