Build with an AI agent

Give a coding agent the API contracts, implementation brief, and acceptance checks.

Give your coding agent one result to implement and the exact sources it should use. Start with a read-only API client or extend the complete learning tutorial into your application.

You need a project the agent can inspect and a server-side environment for ADAPT1_API_KEY. Give the agent the variable name, never the key’s value.

Give the agent a bounded build brief

Choose one prompt. Replace the application requirement at the end, then run it in your repository.

Read-only integration

Add a server-side Adapt-1 integration to this repository.

First inspect the language, framework, package manager, test runner,
environment-variable conventions, and server/client boundary.

Read:
- https://docs.reilabs.org/docs/neuroadapt/quickstart.md
- https://docs.reilabs.org/docs/neuroadapt/request-contracts.md
- https://docs.reilabs.org/neuroadapt-openapi.json
- https://docs.reilabs.org/docs/neuroadapt/errors-and-reliability.md

Implement:
- Follow the repository's existing HTTP-client and error-handling patterns.
- Read ADAPT1_API_KEY from the server environment; never expose or log it.
- Default ADAPT1_BASE_URL to
  https://rei-neuroadapt-api.reilabs.org/api/v1.
- Add one function accepting a nonempty message and sending
  POST {baseUrl}/memory/query with:
  {
    "session_id": "ignored",
    "user_message": <the caller's message>,
    "top_k": 5,
    "include_reasoning": true,
    "update_memory_state": false
  }
- Send Authorization: Bearer <ADAPT1_API_KEY> and JSON content type.
- Validate the request against MemoryQueryRequest and validate the response
  fields the application consumes. Do not fabricate a response model.
- Add a finite timeout and useful errors for missing configuration, non-2xx
  status, malformed JSON, unexpected shape, and transport failure.
- Return the structured result directly; an LLM is not required.
- Add placeholder variable names to .env.example, not a real secret.
- Test with mocked HTTP. Do not call live services or write persistent state.
- Include a short application usage example.

Run the repository's relevant formatting, linting, type checks, and tests.
Report the files changed, commands run, and results. Identify assumptions
and untested behavior explicitly. Do not make unrelated changes.

Application requirement:
[Describe the API route, server action, job, or CLI that should use the result.]

Sources the agent should use

Source	Purpose
Documentation index	Find the relevant pages
Choose a workflow	Select the result, state scope, and learning relationship
Quickstart	Confirm the base URL, authentication, and first request
HTTP and contracts	Understand isolation, read/write controls, and schema coverage
OpenAPI snapshot	Validate fields and limits that the snapshot actually describes
Errors and reliability	Handle timeouts and ambiguous stateful writes

When the agent cannot read web pages, supply the relevant Markdown pages and OpenAPI file locally. Refresh them before changing the integration; do not let an old local snapshot become an invented API contract.

Review the implementation

1. Check the request boundary

   Confirm the versioned base URL, bearer header, field names, types, and state scope. session_id: ignored is a compatibility placeholder, not a tenant selector. Do not allow browser code to read the API key.

2. Check result handling

   Reject malformed or unexpected responses. Treat empty evidence, accumulating state, and abstention according to the route. A confidence field is not automatically a correctness probability; a stored write is not automatically an admitted update.

3. Check state and retries

   Verify which operations can change state. Preserve Domain IDs for continued use, avoid resets as setup shortcuts, and reconcile an ambiguous write before resubmitting it. Mock tests must not call the live API.

4. Verify independently

   Run the direct request in the quickstart with a dedicated test key before debugging the application integration. Then run the generated application path. Keep sanitized failures and actual response records; never paste authorization headers into a prompt.

An optional language layer can articulate an already validated result. Keep the original structured result and its evidence available; do not replace the API integration with a language model that guesses what Adapt-1 would return.

Extend one workflow at a time

Continuity and correction

Add retained evidence without inventing a Domain requirement.

Discovery configuration

Change the target or discovered structure with a matching event contract.

Feedback from execution

Bind a measured outcome to the actual decision or context.

Numeric control

Keep trajectory configuration, executor settings, and recovery semantics distinct.