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

# Fundamentals

## Overview

nuwacom processes requests using large language models (LLMs). These models generate text through prediction rather than looking up information. This creates strengths, limitations, and common error patterns that apply across all parts of the platform: Chat, Agents, Workflows, and Apps. This page explains the four mechanisms that determine how models behave: how a model works, context, the context window, and the role of sources.

## Key Concepts

* **Language model**: A statistical model that calculates the most likely continuation of an input. It does not store factual knowledge like a database but learns patterns from training data.
* **Knowledge cutoff**: The point in time up to which the training data extends. Events, products, and figures after this date are unknown to the model unless a source is provided.
* **Hallucination**: An output that is factually incorrect but linguistically plausible. It occurs when the model fills a gap with the statistically most likely continuation.
* **Context**: All information available to the model when generating a response: prompt, chat history, attachments, selected sources, and workspace configuration.
* **Context window**: The maximum amount of context a model can process per request, measured in tokens.
* **Grounding**: Basing a response on provided sources (Knowledge Base, attachments, Connectors, web search) rather than relying on training data.

## Why This Knowledge Matters

* **Understand common errors**: Invented figures, forgotten instructions in long chats, and generic responses instead of company-specific answers each have an identifiable cause and a corresponding solution.
* **Configure instructions at the right level**: Depending on where instructions are stored, they apply to a single response, a chat, or the entire workspace.
* **Select sources before submitting a request**: Whether the Knowledge Base, an attachment, or web search is active determines where information comes from and how it can be verified.
* **Focus verification efforts**: Check results where models are systematically unreliable rather than where they perform consistently.

## How a Language Model Works

A language model breaks input into tokens (word components) and calculates the most likely continuation at each position. The output is generated token by token. The model does not access a factual database or perform lookups unless a source or tool is connected. Domain knowledge, reasoning patterns, and writing style come from training data.

The output is not deterministic: Repeating the same request can produce different wording and, in some cases, different content.

### Reliable and Unreliable Tasks

| Reliable without a source | Unreliable without a source |
| - | - |
| Rewriting, shortening, structuring, or translating provided text | Specific facts: figures, names, dates, prices, quotes |
| Answering based on an attachment or active source | Events and products released after the knowledge cutoff |
| Creating drafts, outlines, and variations | Internal company policies, processes, and responsibilities |
| Classifying, comparing, and identifying patterns in text | Multi-step calculations and exact aggregations |
| Extracting structured information from provided text | Claims of completeness ("all", "none", "always") |

### Hallucinations

When information is missing, the model does not stop. Instead, it generates the statistically most plausible continuation. An invented metric, legal provision, or contact person can appear with the same confidence and linguistic quality as correct information. Fluent wording, clear structure, or precise decimal figures do not indicate factual accuracy.

Hallucinations can be reduced but not completely eliminated. The most effective measures in nuwacom are activating relevant sources, instructing the model to identify missing information rather than fill gaps, and verifying the categories listed under "Verify Results".

> [!NOTE]
>
> nuwacom offers several models to choose from. They differ in speed, context window size, and performance on complex tasks, but not in the fundamental behavior described here. Knowledge cutoffs and context window sizes depend on the model and may change with new releases.

## Context

Context includes all information provided to the model as input when generating a response. Only this information influences the response. Content from other chats, files that have not been attached, or sources that have not been selected are not available to the model.

![Image (48)](https://mintcdn.com/nuwacomgmbh/0bwMdFtdbsQwhDVx/images/image-\(48\).png?fit=max\&auto=format\&n=0bwMdFtdbsQwhDVx\&q=85\&s=38ab3aab19eef7e9efcfa20c6dccfa7b)

Three levels of context: Prompt (applies to one response), Chat (applies to the conversation), Workspace (applies wherever enabled).

| Level | Components | Scope |
| - | - | - |
| Prompt | Instructions, objective, audience, format, length | One response |
| Chat | Conversation history, attached files, selected sources, chosen model | Current chat |
| Workspace | Knowledge Base, writing style, Design System, Skills, Connectors, Agent configuration | Every chat where they are enabled |

This leads to a general rule: Instructions should be stored at the level where they need to apply. A brand's tone of voice is configured once as a writing style rather than repeated in every prompt. A price list belongs in the Knowledge Base rather than being repeatedly attached.

**Priority when instructions conflict.** When instructions from different levels contradict each other, the more specific and recent instruction generally takes precedence. A prompt can override chat-level instructions for one response, and a chat can adjust workspace defaults for a conversation. Workspace settings that enforce policies, such as security restrictions in Agents, are exceptions and cannot be overridden through a prompt.

### Task Context in a Prompt

The model cannot independently determine the intended audience, purpose, or scope of a task. Providing these three details influences the result more than specific prompting techniques:

* **Audience**: Who will read the result, and what prior knowledge do they have?
* **Purpose**: What decision or action should follow from the result?
* **Scope and format**: What length, structure, and output format are required (table, paragraphs, list)?

The same attachment, two prompts. Without task context:

```text theme={null}
Summarize the attached marketing report.
```

With task context:

```text theme={null}
Audience: Marketing Lead. Purpose: Decide how to reallocate the budget between channels. Output: A table of all channels performing below target, including actual values, targets, and percentage deviations, followed by a two-sentence agency recommendation.
```

The first prompt produces a summary of the document. The second produces information structured to support a decision. The difference is not the prompt's length but the information that was previously missing.

## Context Window

The context window defines the maximum number of tokens a model can process per request. One token corresponds to roughly three-quarters of an English word. German text generally requires more tokens per word because of longer words and compound nouns. With each response, the entire previous chat is submitted again: all messages, responses, attachments, and sections retrieved from sources. The amount of context therefore increases with every message.

Two effects occur before the context window is full:

* **Dilution**: The more content the context window contains, the less relative weight individual instructions carry. Earlier instructions become less influential, particularly those located in the middle of a long conversation.
* **Conflicting instructions**: Multiple corrections to the same point remain in the context window simultaneously. The model weighs these instructions rather than strictly following the latest one.

Once the context window is exhausted, older content is truncated or compressed. Instructions from the beginning of the chat may then no longer be available.

![Image (49)](https://mintcdn.com/nuwacomgmbh/0bwMdFtdbsQwhDVx/images/image-\(49\).png?fit=max\&auto=format\&n=0bwMdFtdbsQwhDVx\&q=85\&s=48bd9cd46239feddc624906f7ae7c672)

Left: A chat after several corrections, with competing instructions in the context window. Right: A new chat containing the latest valid version and a complete set of instructions.

### Symptoms and Solutions

| Symptom | Cause | Solution |
| - | - | - |
| A previously followed instruction is ignored | Earlier instructions have been diluted or truncated | Start a new chat, attach the latest valid version, and restate the instructions |
| A response contradicts an earlier response | Competing corrections remain in the context window | Instead of correcting again, start a new chat with consolidated instructions |
| Details from a large attachment are missing | Only parts of the document were included in the context window or retrieved | Specify the relevant section or add the document to the Knowledge Base |
| Response quality declines after changing topics | Irrelevant context competes with the new task | Use one task per chat |

> [!TIP]
>
> Practical guideline: If the second correction to the same issue does not improve the result, starting a new chat with consolidated instructions is usually faster than making a third correction.

## Sources and General Knowledge

Without an active source, the model responds using its training data. Its answers are general, limited by its knowledge cutoff, and do not include internal company information. When a source is active, relevant content is loaded into the context window. The response can then be based on that information and include references to the source.

Consider the same question: "How many days per week are employees allowed to work from home?" Two possible results:

| Attribute | Without a source | With Knowledge Base |
| - | - | - |
| Response | "In most companies, two to three days per week are common. Specific arrangements are defined by company policies." | Specific policy, request procedure, and reference to the relevant section |
| Origin | Training data | Document in the workspace |
| Verifiability | None | Reference to the document |

Phrases such as "in most companies", "typically", or "as a general rule" may indicate that no source was used.

### How Sources Enter the Context

The Knowledge Base is not passed to the model in its entirety. For each request, semantic search identifies the most relevant sections and loads them into the context window. This has two implications:

* **Retrieval accuracy depends on the request**: A precise question using terminology from the document is more likely to retrieve the relevant sections than a general question.
* **Missing information may be filled in**: If none of the retrieved sections contains the requested information, the model may continue answering from its training data without indicating the gap unless explicitly instructed to do so.

Depending on their size, attached files are either processed in full or provided in sections.

### Source Types Compared

| Source | Freshness | Reviewed by | Reference | Use Case |
| - | - | - | - | - |
| Knowledge Base | As of upload | Workspace admin | Document + section | Policies, processes, product knowledge |
| File attachment | As of file version | User | Document + section | Individual documents, analyses |
| Connector / MCP | Live | Source system | Record | CRM, calendar, email, tickets |
| Web search | Live | No one | URL | Market data, news, external facts |

> [!WARNING]
>
> Web search addresses the problem of outdated information, not the need for verification. A figure retrieved through web search still comes from a website and requires verification, just like a figure generated from training data.

Prompt template for source-grounded responses:

```text theme={null}
Answer exclusively based on the active sources. For each statement, specify the document and section. If information is not available in the sources, explicitly state that it is missing instead of adding information from elsewhere.
```

The final sentence instructs the model not to fill gaps using its training data.

## Verify Results

Language model outputs should be treated as drafts. Verification should focus on the categories where models are systematically unreliable:

| Category | Risk | Verify against |
| - | - | - |
| Numbers, metrics, amounts | Plausible inventions, incorrect year or unit | Source document, raw data |
| Names, responsibilities, dates | Information transferred from similar cases | Source system, organizational chart |
| Quotes, legal provisions, page numbers | References that appear exact but are invented | Original document |
| Legal and contractual statements | General rules instead of specific agreements | Responsible specialist team |
| Claims of completeness | Only retrieved sections were considered | Independent search within the document |

### Verification Methods in nuwacom

* **Request a source reference**: "Show the passage in the document where this figure comes from." If the model cannot identify a passage, the information is not supported by the source.
* **Ask about the origin**: "Where does this statement come from?" Source-grounded responses refer to the document. Responses based on training data may be rephrased or qualified.
* **Compare with raw data**: For decision-making documents, compare the metrics directly with the source. This typically takes only a few minutes per document.
* **Repeat the request in a new chat**: For critical statements, ask the same question again without the previous conversation history. If the answers differ, at least one is incorrect.

### When to Stop Correcting

Starting a new chat is preferable to making another correction when any of the following conditions applies:

* The second correction to the same issue has no effect.
* The topic changes.
* Previously followed instructions are ignored.

> [!NOTE]
>
> For approvals, exceptional cases, and legal, tax, or employment-related questions, the responsible specialist team remains the authoritative source. nuwacom can help prepare the request but does not replace the team's assessment.

## What Language Models Cannot Do

* **No factual lookup without a source**: The model does not look up information independently. Without an active source, Connector, or web search, information comes from training data.
* **No knowledge beyond the training cutoff**: Events, releases, and prices after the knowledge cutoff are unknown unless provided through a source.
* **No access to other chats**: Chat history and attachments are specific to each chat. Only workspace-level resources can be available across chats.
* **No consistently reliable arithmetic**: Multi-step calculations and aggregations involving many values are error-prone. Data Analysis with code execution is better suited for exact results.
* **No reliable indication of uncertainty**: The model does not consistently indicate when it is guessing. A confident tone is not a measure of accuracy.
* **No guarantee of completeness**: Responses are based on the retrieved sections, which may not represent the entire document collection.
* **No reproducibility guarantee**: The same request may produce different outputs.

## Good to Know

* **Changing models does not change fundamental behavior**: Switching to a different model does not resolve a full context window or a missing source.
* **Select sources before submitting a request**: A source activated afterward affects the next response, not previous responses.
* **One task per chat**: Changing topics within the same chat can reduce the quality of results for both tasks.
* **Save intermediate versions**: Save a suitable version as content or transfer it to a new chat before continuing to iterate.
* **Generic wording as a signal**: Phrases such as "typically", "in most cases", or "as a general rule" may indicate an answer without a source.
* **Verify content, not presentation**: Clear structure, fluent language, and detailed explanations do not guarantee factual accuracy.

## Example Prompts

* *"Audience: Executive management. Purpose: Budget decision. Length: One page. Summarize the attachment accordingly."*
* *"Answer only using the Knowledge Base and specify the document and section for each statement."*
* *"Show the passage in the document where the figure of 12.4 percent comes from."*
* *"Which statements in your previous response are not supported by the active sources?"*
* *"Here is the latest valid version. Revise it according to the following complete instructions: ..."*

## FAQ

> **Why does the model mention a rule that is not included in our policy?**
>
> Either no source was active, or the retrieved sections did not contain the information, and the model filled the gap using training data. To address this, activate the relevant source, request a source reference, and use the prompt template for source-grounded responses.

> **Why does the model stop following earlier instructions in a long chat?**
>
> The context window is heavily populated, causing earlier instructions to be diluted or truncated. Start a new chat with the latest valid version and a complete, consolidated set of instructions.

> **Is a response generated using web search verified?**
>
> No. Web search provides current information, but the content is not automatically verified. The URL makes verification possible but does not replace it.

> **Can the model access files from other chats?**
>
> No. Attachments and conversation history are specific to each chat. Only workspace-level resources, such as the Knowledge Base, can be available across chats.

> **Does a more powerful model help prevent hallucinations?**
>
> To a limited extent. More capable models may hallucinate less frequently, but hallucinations cannot be eliminated. Using active sources and verifying references generally has a greater impact than changing models.

> **Why does the same request produce different responses?**
>
> Language models are not deterministic. Differences in wording are normal, while differences in factual information indicate that verification is needed.

> **Can the model calculate totals and metrics from a table?**
>
> Only with limited reliability. For exact calculations, Data Analysis with code execution is the better option.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.