Platform

AI Training

In Daguito, "training" an agent does not mean retraining a model. It means improving how your agent behaves through the right levers: the knowledge it can consult, the instructions you give it, the memory of each conversation, and the logs that tell you what went well or wrong. It's an iteration loop, not a machine-learning process.

What "training" means in Daguito

When people talk about "training" a chatbot, they usually imagine feeding it examples until it learns. Daguito takes a different, more practical approach: the model already knows how to reason and talk; your job is to give it the right context and tune its behavior.

Your agent improves through four levers you fully control, without touching the model:

• Knowledge Base: documents the agent consults at answer time.
• Prompts: the instructions and personality you define for each agent.
• Memory: what the agent remembers within a conversation.
• Observability: the execution traces that show what the agent decided and why.

Knowledge Base

The most powerful way to "train" an agent is to give it knowledge it can consult. Daguito uses Knowledge Base: your documents are chunked, turned into vectors, and stored in a Knowledge Base. When a question arrives, the agent retrieves the relevant chunks and answers grounded in them.

How knowledge gets in

You can feed a Knowledge Base in several ways:

• Web crawl: a sitemap plus individual URLs that Daguito traverses and chunks.
• File upload: PDFs (with a text layer) and plain text.
• Platform sync: e-commerce connectors such as Shopify, WooCommerce, and Tiendanube that pour your catalog into a Knowledge Base.

Metadata to scope context

Each chunk can carry metadata (for example categoria or vigencia: 2026). At query time you can filter by those fields so the agent only sees the right knowledge: current-year promotions, a specific product line, or a region. Daguito stores and matches metadata verbatim, never interpreting its meaning.

The retrieval pipeline

Behind every answer there is a five-stage pipeline that decides which chunks reach the agent:

1. Query rewrite: the user's question is reformulated to search better.
2. Vector search: the query is turned into an embedding and the closest chunks are retrieved by meaning.
3. Metadata filter: discards chunks that don't meet the required fields.
4. Reranking: a model orders the candidates by true relevance to the question.
5. Caching: frequent results are stored with a TTL to answer instantly.

Alongside the chosen chunks, the pipeline returns each one's content, metadata, provenance, and relevance score, plus per-stage latencies. That lets you see exactly what each answer is grounded in:

{
  "chunks": [
    {
      "id": "chunk_a1b2c3",
      "source_id": "kb_envios",
      "content": "Enviamos a Bogotá en 24–48h por mensajería...",
      "metadata": { "categoria": "envios", "vigencia": "2026" },
      "provenance": { "url": "https://tienda.com/envios" },
      "score": 0.87,
      "rerank_score": 0.91
    }
  ],
  "query_original": "¿hacen envíos a bogotá?",
  "query_rewritten": "tiempo y cobertura de envío a Bogotá",
  "from_cache": false,
  "latency": { "rewrite_ms": 120, "retrieve_ms": 45, "rerank_ms": 80, "total_ms": 260 }
}

Prompts and agent voice

The system prompt is where you define who your agent is, how it talks, and what it can or cannot do. It's the fastest lever: edit the text, redeploy the flow, and the behavior changes instantly.

Daguito composes the final prompt in layers, from general to specific:

• Global personality: the prompt and constraints shared across your whole organization.
• Node prompt: the instructions specific to the agent you're configuring.
• Role defaults: a baseline text based on the agent type when you don't write your own.

Beyond the text, two parameters shape the output style: temperature (how much the model risks) and max_tokens (how long the answer can be).

// Configuración del nodo agente
{
  "model": "...",
  "system_prompt": "Eres el asistente de la tienda. Sé breve y cordial.",
  "temperature": 0.7,
  "max_tokens": 1024
}

Conversation memory and context

So an agent doesn't "forget" what was said two messages ago, Daguito keeps per-conversation memory. This adapts its replies without changing the prompt: the agent remembers what it already knows about the user.

Structured facts

Daguito automatically extracts typed "facts" from the conversation and stores them. Each fact has a clear shape:

• key and value: for example ciudad_envio = "Bogotá".
• type: string, number, array, enum, or object.
• priority and persistence: critical facts are rendered first and never truncated.

Summaries

For long conversations, a rolling summary compresses older turns into a few sentences. This keeps the agent on track without spending the whole context window repeating itself. You can tune when it's generated and in which language.

Search relevant context

Beyond the summary and facts, Daguito indexes each conversation's turns so the agent can run a semantic search over the chat itself to recover a relevant earlier message, with source attribution.

Behavior tuning and tools

Beyond the prompt and knowledge, each agent exposes parameters that fine-tune its behavior. They're all configured per agent:

• temperature (0–2): low for deterministic replies, high for more creativity.
• max_tokens: ceiling on answer length; controls cost and verbosity.
• history_turns: how many previous turn-pairs are kept in context.
• recent_turns: how many recent turns are loaded from the message history to seed context when an execution starts with no transcript.
• max_tool_iterations (1–32): cap on tool calls in a single turn, to avoid loops.

Tool configuration

An agent can use tools. Daguito accepts three shapes:

• Inline: declared on the agent itself; they usually emit a UI intent to the frontend (emit_only).
• Handler: tools registered on the server, such as Knowledge Base search or web search.
• Flow: another flow that runs as a sub-flow and returns its result to the model.

Each tool's output includes retrieval scores and source attribution, so you know what the agent based its answer on.

Observability and feedback

You can't improve what you can't see. Daguito traces every execution so you understand what your agent did:

• Execution traces: every model call, Knowledge Base retrieval, and tool invocation carries an execution_id, flow_id, and trace_id.
• Message audit: every inbound and outbound is persisted before any volatile operation.
• Chat ratings: the thumbs up or down on each reply is stored in the message_feedback table, with an optional reason, for analytics.
• Pipeline latencies: per-stage metrics (rewrite_ms, retrieve_ms, rerank_ms, total_ms).

The iteration loop

Improving an agent is a short, repeatable loop. In practice it looks like this:

1. Edit the system prompt, redeploy the flow, and test with real inputs.
2. Review the execution traces to see what the agent retrieved and decided.
3. Refine the knowledge: add or fix documents and re-ingest (chunk, embed, index).
4. Adjust the parameters: temperature, history_turns, or max_tokens for style and cost.
5. Monitor quality with the execution dashboards and the message audit, then repeat.

What's next?