Video summary

Вебинар: Автоматизация бизнес-процессов с AI: n8n + Dify на практике

Main summary

Key takeaways

Technology

Topic

Practical webinar demonstrating how to automate business processes with AI by combining n8n (automation/workflow) and Dify (open-source platform for building AI apps, including vector knowledge bases and chat UIs). The live demo used a simple “door store” knowledge base and Telegram as an entry channel.

Key technological concepts explained

  • Retrieval-Augmented Generation (RAG)
    • Store business documents as embeddings in a vector DB.
    • Split documents into chunks, retrieve the most-similar chunks for a user query, and include them in the LLM context to reduce hallucinations and token cost.
  • Embeddings and chunking
    • Chunk size / overlap strategy (example: ~3,000 characters per chunk as a starting point; use overlap to preserve semantics).
    • Rule of thumb: one token ≈ 3 characters (rough guide).
  • Search modes
    • Vector, full-text, hybrid (vector + full-text / ranking).
    • Hybrid mode was demonstrated for better relevance.
  • Prompt engineering / system-prompt best practices
    • Limit the LLM to facts, use local memory, set format rules for channels (e.g., Telegram), and include examples.
  • Orchestration patterns
    • On-demand RAG: model or agent decides when to call the KB (tool invoked only if needed).
    • Forced-first retrieval: always call the KB first and feed results to the model (reduces hallucination but requires tighter KB structure).
  • Deployments and local models
    • n8n and Dify are open-source and can be deployed locally, on-prem, or in cloud (docker-compose, Docker, Kubernetes).
    • Telegram webhooks require a domain + SSL (unless using proxies).
    • Dify supports multiple LLM vendors and local models (e.g., via Ollama / localhost), enabling fully offline workflows.

Product / feature highlights — Dify

  • Open-source platform for AI apps with:
    • Visual no-code / low-code studio (recently added code editor and Python support for advanced blocks).
    • Vector knowledge base with embedding selection, chunking settings, and per-chunk metadata editing in the UI.
    • Support for multiple embedding/LLM providers (OpenAI, local models via Ollama, etc.).
    • API endpoints (e.g., dataset retrieve) for integration with external workflow engines.
    • Chat/app templates and the ability to publish a chat app and issue API keys.
    • Ability to edit chunks inside the UI without full re-upload.

Product / feature highlights — n8n

  • Open-source workflow automation platform with a visual workflow editor and many integrations (Telegram, email, etc.).
  • Features used in the talk:
    • Agent/LLM blocks.
    • Memory (simple per-user memory; supports external DBs like Postgres/Mongo).
    • Retry logic and conditional steps.
    • Ability to call Dify via HTTP request node to retrieve relevant chunks (used as a “tool” inside the agent).

Demo / tutorial steps (practical guide)

  1. Prepare documents (PDF, Word, Excel, CSV, etc.). Prefer consistent structure and parsers for uniform chunking.
  2. Upload files to a Dify dataset and configure chunking:
    • Set separator, max characters, overlap.
    • Choose an embedding model (OpenAI or local).
    • Trigger embedding calculation (background process).
  3. Note the dataset ID (in the dataset URL) for API calls.
  4. In n8n:
    • Create a trigger (Telegram message).
    • Create an agent block with a system prompt instructing language, factual-only answers, format rules, and examples.
    • Add a tool: HTTP POST to Dify retrieve endpoint with a JSON body containing the query (user message) and retrieval parameters (method: hybrid/vector/full-text).
    • Configure the model node (e.g., OpenAI GPT-4o Mini in demo), memory, and retries.
  5. Test end-to-end:
    • User message -> n8n trigger -> HTTP retrieve to Dify -> top chunks returned -> LLM composes reply -> send to Telegram.
  6. Alternative flow:
    • Always call Dify first as a separate HTTP tool step before the LLM if the KB is tightly curated.
  7. Optionally use Dify Studio to build and publish an internal chat app (chatflow / agent templates) and reuse the same API from n8n.

Best practices, tips and caveats

  • KB structure and metadata matter
    • Use consistent parsers and add metadata/keywords per chunk to improve relevance and filtering.
    • Avoid duplicated or ambiguous sections (e.g., old vs. current product info).
  • For hierarchical or large taxonomies
    • Consider iterative retrieval (multi-step filtering by taxonomy levels).
  • Editing KB content
    • Edit chunks directly in the Dify interface to quickly fix content without full re-ingest.
  • Embedding model selection
    • Use cloud models (OpenAI) if data sensitivity allows; for sensitive data, use local models via Ollama or other localhost connectors.
  • Image handling
    • Some nodes prefer image URLs rather than raw base64. Workarounds include temporary storage (Google Drive) or using nodes that support image upload. Image editing workflows were not fully demonstrated.
  • Production trade-offs
    • Open-source + low-code: fast prototyping, low initial cost, rapid iteration, strong community support.
    • Downsides: potential scaling constraints depending on choices, security/testing/auditing requirements, and the need to patch/monitor open-source components.
    • Custom development: longer timelines (weeks–months) but offers more control and scalable solutions tailored to needs.

Issues encountered & debugging topics

  • Agent reliance on message history instead of re-querying the KB — mitigations: tighten prompts or call KB explicitly each time.
  • Persistent hallucinations — address via KB tuning, prompt rules, metadata filtering, or forced retrieval-first flow.
  • Retry logic is valuable to handle transient OpenAI/Dify outages.

Resources mentioned

  • Dify API: dataset retrieve endpoint and dataset ID usage.
  • Embedding and LLM vendor options: OpenAI, Ollama/local.
  • Deployment methods: Docker/docker-compose or Kubernetes.
  • Integration examples: Telegram webhook, exporting Dify chat app via API keys.

Main speakers / sources

  • Presenter: Ivan Chetverikov — Lead Architect at RAFT (demonstrator and primary speaker).
  • Webinar/host: Dextau webinar series.
  • Platforms referenced: Dify, n8n, OpenAI, Ollama, RAFT.

If you want, I can: - Extract the exact n8n workflow steps (nodes + JSON body example for the Dify retrieve request). - Provide a sample system prompt (the presenter offered to share the prompt and workflow). - Draft a short checklist for KB ingestion and chunking metadata to minimize hallucinations.

Original video