> ## Documentation Index
> Fetch the complete documentation index at: https://hmm.heyhyper.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# correct: Fix Wrong Information in Hyper Team Memory

> Record a human correction to Hyper's shared memory. Uses vector search to find every affected document and applies the fix across all of them.

The `correct` tool is how you fix wrong information in Hyper. When a teammate tells you that something Hyper knows is incorrect, `correct` records the right information and then searches your entire workspace for every document that contains the wrong version — and applies the correction to all of them. This ensures the mistake doesn't resurface from an older memory document even after you've corrected the obvious one.

<Warning>
  **Only call `correct` when the user explicitly tells you something in Hyper is wrong and provides the correct information.** Do not call this tool on your own initiative, based on suspicion, or because retrieved context seems outdated. The correction pipeline modifies memory documents across your entire workspace — it should only run when a human has made a deliberate correction.
</Warning>

## Parameters

<ParamField name="correction" type="string" required={true}>
  The user's correction, passed as their **exact words**. Do not paraphrase or summarize. Passing the original phrasing gives the correction pipeline the most accurate signal for finding and updating the affected documents. Example: `"We actually chose MySQL, not PostgreSQL — the PostgreSQL entry in Hyper is wrong"`.
</ParamField>

## Returns

<ResponseField name="response" type="string">
  Returns `"Correction recorded. Hyper will update its knowledge accordingly."` on success. The correction pipeline runs asynchronously — affected documents are updated in the background.
</ResponseField>

## How It Works

When you call `correct`, Hyper does three things:

1. **Records the correction** — stores the user's exact words as a correction event.
2. **Runs a vector search** — finds every memory document in the workspace that semantically relates to the wrong information.
3. **Applies the correction** — updates each affected document to reflect the right information, so the error can't resurface from an older entry.

This is more thorough than a targeted edit. If the same wrong fact was captured in five different memory documents — from five different conversations — all five get corrected.

## Example Calls

### Correcting a technology decision

The user says: *"We actually chose MySQL, not PostgreSQL — the PostgreSQL entry in Hyper is wrong."*

```python theme={null}
correct(
  "We actually chose MySQL, not PostgreSQL — the PostgreSQL entry in Hyper is wrong"
)
```

```text theme={null}
Correction recorded. Hyper will update its knowledge accordingly.
```

### Correcting a person's status

The user says: *"Marcus finished the AML integration last Friday — Hyper says he's still in progress but it's done."*

```python theme={null}
correct(
  "Marcus finished the AML integration last Friday — Hyper says he's still in "
  "progress but it's done"
)
```

```text theme={null}
Correction recorded. Hyper will update its knowledge accordingly.
```

### Correcting a timeline

The user says: *"The billing integration wasn't deferred to Q3 — we actually cut it from the roadmap entirely."*

```python theme={null}
correct(
  "The billing integration wasn't deferred to Q3 — we actually cut it from the "
  "roadmap entirely"
)
```

```text theme={null}
Correction recorded. Hyper will update its knowledge accordingly.
```

## When to Use correct vs. remember

These two tools serve different purposes and should not be used interchangeably:

| Situation                                        | Tool to use                                   |
| ------------------------------------------------ | --------------------------------------------- |
| The user wants to save something new             | [`remember`](/mcp/tools/remember)             |
| The user says something in Hyper is **wrong**    | `correct`                                     |
| You think retrieved context might be outdated    | Neither — wait for user confirmation          |
| The user provides updated information unprompted | `remember` (it's an update, not a correction) |

<Tip>
  The clearest signal to call `correct` is when the user uses language like: "that's wrong", "Hyper has that wrong", "that's not right", "the correct version is...", or "update Hyper — X is actually Y". When in doubt, ask the user to clarify before running a workspace-wide correction.
</Tip>

## Why Exact Wording Matters

`correct` uses the user's exact words as input to the vector search that identifies affected documents. If you paraphrase the correction, the search may miss documents that would have matched the original phrasing. Always pass `correction` as a verbatim quote of what the user said.