search-engine-core cpp-api-patterns.instructions.md

C++ coding instructions for Result values, MongoDB BSON data, and aggregation pipelines. They give exact API patterns for a project using MongoDB's C++ library.

In plain words
What is it for?
Use them while writing or reviewing the project's C++ code that handles operation results, MongoDB strings, queries, and aggregation pipelines.
Why use it?
They prevent common compilation errors caused by guessing method names or using the wrong data-access patterns. The input focuses on the listed Result, BSON, aggregation, and optional-value checks.

Instructions file for GitHub Copilot

Install

Getting it into your agent

One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.

agentmods
npx agentmods add instructions/hatefsystems/search-engine-core/cpp-api-patterns
Clone the repo
git clone --depth 1 https://github.com/hatefsystems/search-engine-core

Made for: GitHub Copilot.

Per session 610 This file is loaded in full into every session.
When invoked 610 The same file — it is already loaded in full.
Security scan A 0 findings. Scan, not verified.
Origin original No closer match found in the catalogue.
Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

ModelPer sessionOnce invoked
Fable 5 $0.00610 $0.00610
Opus 5 $0.00305 $0.00305
Sonnet 5 $0.00122 $0.00122
Haiku 4.5 $0.00061 $0.00061

Measured yesterday against content hash 3094332710fb, method: parsed. Prices are Anthropic first-party input rates as of 2026-08-30, from the pricing page.

Security

Grade A, and why

search-engine-core cpp-api-patterns.instructions.md scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured yesterday.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Nothing flagged

None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.

.github/instructions/cpp-api-patterns.instructions.md · 91 lines

How it starts

The opening of the file, as written. The whole thing — 91 lines — stays where its author put it; the contents beside it link to each section on GitHub.

C++ API Patterns - Zero-Error Rules

Never guess API usage. Use these patterns to prevent compilation errors.

Result Interface

// ❌ WRONG - These methods DON'T EXIST
if (result.isSuccess()) { }
result.getError(); result.getValue();
Result<T>::success(value); Result<T>::failure(message);

// ✅ CORRECT
if (result.success) { }
result.message
result.value
Result<T>::Success(value, "msg")
Result<T>::Failure("error")

MongoDB BSON String Access

// ❌ WRONG
element.get_utf8().value.to_string()
element.key().to_string()

// ✅ CORRECT
std::string(element.get_string().value)
std::string(element.key())

MongoDB Aggregation

// ❌ WRONG
auto pipeline = document{} << "pipeline" << array{...} << finalize;
collection.aggregate(pipeline.view())

// ✅ CORRECT
mongocxx::pipeline pipeline;
pipeline.match(document{} << "field" << "value" << finalize);
pipeline.group(document{} << "_id" << "$field" << finalize);
collection.aggregate(pipeline)

Optional / Result Checks

// ❌ WRONG
if (result) { }  // run_command
if (!result) { } // find_one

// ✅ CORRECT
if (!result.empty()) { }      // run_command
if (!result.has_value()) { } // find_one (std::optional)

Quick Reference

if (result.success) { auto v = result.value; }
std::string str = std::string(element.get_string().value);
mongocxx::pipeline pipe; pipe.match(filter).group(grouping);
if (findResult.has_value()) { }

Code Template Checklist (Before Implementing)

  • Use Result<T>::Success() and Result<T>::Failure() (capital letters)
  • Include MongoDB singleton: MongoDBInstance::getInstance()
  • Use lazy initialization for controller services
  • Pair res->onData() with res->onAborted() for POST endpoints
  • Use LOG_DEBUG() instead of std::cout
  • Check BSON strings with std::string(element.get_string().value)
  • Use mongocxx::pipeline for aggregations
  • Use basic builder with .extract() for complex MongoDB updates

Read the full file on GitHub · 91 lines

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

  1. yesterday First seen · 91 lines · 610 tokens per session scan A 3094332710fb

Subscribe to this mod's changes

search-engine-core cpp-api-patterns.instructions.md is an instructions file published in the GitHub repository hatefsystems/search-engine-core (5 stars, last pushed 27d ago), licensed Apache-2.0. It adds 610 tokens to every session, about $0.0030 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-31.

Related

Other instructions, from other repositories

Xapiand AGENTS.md

Instructions for Kronuz/Xapiand, covering agents.md — working in the xapiand codebase, first, the big split: own code vs. vendored, where things live, build & toggles and verifying changes end-to-end (the docs are a test suite).

Kronuz/Xapiand · 2,843 tokens

electron CLAUDE.md

Instructions for electron/electron, covering electron development guide, running nodemodules binaries, project overview, directory structure and build tools setup.

electron/electron · 2,653 tokens

electron copilot-instructions.md

Instructions for electron/electron, covering copilot instructions for electron, build system, linting, running a single test and example: npm run test -- -g "ipc".

electron/electron · 1,178 tokens

compiler-explorer AGENTS.md

Instructions for compiler-explorer/compiler-explorer, covering agents.md, build & test commands, important workflow requirements, style guidelines and architecture guidelines.

compiler-explorer/compiler-explorer · 2,422 tokens

weaviate CLAUDE.md

Instructions for weaviate/weaviate, covering claude.md, no bug is ever out of scope, build & run, build the binary (cgoenabled=0, static linking) and build debug binary (with delve support).

weaviate/weaviate · 2,591 tokens

compiler-explorer copilot-instructions.md

Instructions for compiler-explorer/compiler-explorer: For each answer to the user, evaluate your level of confidence in the correctness of the answer on a scale from 1 to 10, where 1 is very uncertain and 10 is absolutely certain. If your confidence level is below 8, state so and suggest ways to verify the answer.

compiler-explorer/compiler-explorer · 60 tokens