Flowise: Framework RAG sin Código para Homelab (Guía Completa 2026)

📋 TL;DR

Flowise es un framework open-source de código bajo/sin código para construir aplicaciones RAG (Retrieval Augmented Generation) usando una interfaz visual drag-and-drop. Basado en LangChain, permite crear flujos complejos de IA sin escribir código, integrando LLMs locales (Ollama, LocalAI) y vector databases (Qdrant, Pinecone, ChromaDB). En esta guía aprenderás a instalar Flowise en tu homelab, crear flujos RAG visuales, integrar con Ollama/LocalAI, y entender cuándo usar Flowise vs Dify.AI vs LangChain. Además, descubrirás cómo Flowise ai puede mejorar tu flujo de trabajo.

Lo que conseguirás:

• ✅ Instalar Flowise en Docker-2025/) en 5 minutos
• ✅ Crear tu primer flujo RAG sin escribir código
• ✅ Integrar con Ollama y LocalAI para LLMs locales
• ✅ Conectar con vector databases (Qdrant, ChromaDB, etc.)
• ✅ Comparar Flowise con Dify.AI y LangChain

Tiempo de lectura: ~20 minutos | Nivel: Intermedio

—

📚 Tabla de Contenidos

1. Introducción
2. ¿Qué es Flowise?
3. Flowise vs Dify.AI vs LangChain
4. Instalación Docker
5. Configuración Avanzada
6. Crear tu Primer Flujo RAG
7. Integración con Ollama/LocalAI
8. Integración con Vector Databases
9. Casos de Uso Prácticos
10. Troubleshooting Común
11. Mejores Prácticas
12. 📦 Descargar Ejemplos
13. Enlaces Relacionados
14. Preguntas Frecuentes
15. Conclusión

—

> 📅 Última actualización: Febrero 2026

> ✅ Verificado con: Flowise v1.4.0 – Febrero 2026

> 🔄 Próxima revisión: Mayo 2026

—

Introducción

Crear sistemas RAG (Retrieval Augmented Generation) tradicionalmente requiere escribir código Python o JavaScript, integrar múltiples librerías (LangChain, LlamaIndex), configurar embeddings, vector databases, y conectar con LLMs. Para desarrolladores y sysadmins que quieren prototipar rápidamente o crear flujos RAG sin profundizar en código, esto puede ser una barrera significativa.

El problema: Construir un chatbot que responda preguntas sobre tus documentos PDF, o un sistema de Q&A sobre tu base de conocimiento, requiere conocimientos de programación, APIs, y arquitectura de RAG. Incluso con frameworks como LangChain, el tiempo de desarrollo puede ser considerable.

La solución: Flowise es un framework open-source que elimina la necesidad de escribir código. Con una interfaz visual drag-and-drop, puedes construir flujos RAG complejos en minutos, conectando componentes como document loaders, text splitters, embeddings, vector stores, y LLMs con simples clics.

En esta guía completa aprenderás:

• Qué es Flowise y cómo se diferencia de Dify.AI y LangChain
• Instalar Flowise en Docker en tu homelab
• Configurar Flowise para producción con PostgreSQL
• Crear tu primer flujo RAG visual sin código
• Integrar con LLMs locales (Ollama, LocalAI)
• Conectar con vector databases (Qdrant, Pinecone, ChromaDB, Weaviate)
• Casos de uso prácticos: chatbot con documentos, Q&A sobre PDFs, búsqueda semántica
• Troubleshooting de errores comunes
• Mejores prácticas de seguridad, escalabilidad y optimización

Ya seas un sysadmin que quiere crear un chatbot interno, un desarrollador que busca prototipar rápidamente, o un entusiasta de homelab explorando RAG, esta guía te dará todo lo necesario para empezar con Flowise.

—

¿Qué es Flowise?

Flowise es un framework open-source (licencia MIT) de código bajo/sin código para construir aplicaciones RAG usando una interfaz visual drag-and-drop. Está construido sobre LangChain, lo que significa que todos los componentes de LangChain están disponibles, pero sin necesidad de escribir código.

Características Principales

1. Interfaz Visual Drag-and-Drop

• Construye flujos RAG arrastrando y conectando nodos
• No necesitas escribir código Python o JavaScript
• Visualización clara del flujo de datos

2. Basado en LangChain

• Compatibilidad total con componentes LangChain
• Todos los document loaders, text splitters, embeddings, y chains disponibles
• Puedes exportar flujos como código LangChain si lo necesitas

3. Soporte para Múltiples LLMs

• Cloud: OpenAI, Anthropic (Claude-vs-windsurf/)), Google (Gemini)
• Local: Ollama, LocalAI, HuggingFace
• Fácil cambio entre modelos sin modificar el flujo

4. Integración con Vector Databases

• Qdrant (recomendado para homelab)
• Pinecone (cloud, managed)
• Weaviate (avanzado, GraphQL)
• ChromaDB (simple, Python-first)
• FAISS (rápido, Facebook)

5. Exportación/Importación

• Exporta flujos como JSON
• Comparte flujos con tu equipo
• Versiona flujos en Git

6. API REST

• Integra Flowise con n8n, webhooks, o cualquier aplicación
• Ejecuta flujos programáticamente
• Crea chatbots personalizados

7. Docker-Ready

• Imagen oficial en Docker Hub
• Fácil despliegue en homelab
• Soporte para PostgreSQL en producción

Arquitectura de Flowise

Flowise está construido con tecnologías modernas:

• Backend: Node.js + Express
• Frontend: React + React Flow (para la interfaz visual)
• Base de datos: SQLite (por defecto) o PostgreSQL (producción)
• Integraciones: LangChain, múltiples LLMs, vector databases

Componentes principales:

1. Flow Builder: Interfaz visual para construir flujos arrastrando nodos
2. Chat Interface: Interfaz de chat integrada para probar flujos
3. API Server: API REST para integración externa
4. Credential Manager: Gestión segura de API keys y credenciales

Ventajas de Flowise

—

Flowise vs Dify.AI vs LangChain

Antes de profundizar en Flowise, es importante entender cuándo usar cada herramienta. Aquí tienes una comparativa detallada:

¿Cuándo usar Flowise?

Usa Flowise si:

• Quieres crear flujos RAG sin escribir código
• Necesitas prototipar rápidamente
• Prefieres una interfaz visual drag-and-drop
• Quieres máxima flexibilidad en la construcción de flujos
• Necesitas integrar con múltiples LLMs y vector DBs

No uses Flowise si:

• Necesitas control total sobre cada línea de código
• Tienes requisitos muy específicos que requieren código personalizado
• Prefieres trabajar directamente con código Python/JS

¿Cuándo usar Dify.AI?

Usa Dify.AI si:

• Prefieres templates predefinidos
• Quieres una estructura más guiada
• Necesitas funcionalidades específicas de Dify (knowledge base, etc.)

¿Cuándo usar LangChain (código)?

Usa LangChain si:

• Necesitas control total sobre el código
• Tienes requisitos muy específicos
• Quieres integrar RAG en aplicaciones existentes
• Prefieres trabajar directamente con código

—

Instalación Docker

La forma más sencilla de instalar Flowise es usando Docker. En esta sección verás dos configuraciones: básica (para desarrollo/pruebas) y producción (con PostgreSQL).

Instalación Básica

Crea un archivo docker-compose.yml:

version: '3.8'

services:
  flowise:
    image: flowiseai/flowise:latest
    container_name: flowise
    ports:
      - "3000:3000"
    environment:
      - PORT=3000
      - FLOWISE_USERNAME=admin
      - FLOWISE_PASSWORD=changeme
    volumes:
      - flowise_data:/root/.flowise
    restart: unless-stopped

volumes:
  flowise_data:

Inicia Flowise:

docker-compose up -d

Accede a Flowise en http://localhost:3000 con usuario admin y password changeme.

Instalación con PostgreSQL (Producción)

Para producción, usa PostgreSQL en lugar de SQLite:

version: '3.8'

services:
  postgres:
    image: postgres:15-alpine
    container_name: flowise_postgres
    environment:
      - POSTGRES_DB=flowise
      - POSTGRES_USER=flowise
      - POSTGRES_PASSWORD=changeme
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped
    networks:
      - flowise_network

  flowise:
    image: flowiseai/flowise:latest
    container_name: flowise
    ports:
      - "3000:3000"
    environment:
      - PORT=3000
      - DATABASE_PATH=postgresql://flowise:changeme@postgres:5432/flowise
      - FLOWISE_USERNAME=admin
      - FLOWISE_PASSWORD=changeme
      - SECRETKEY_PATH=/root/.flowise/.flowise
    depends_on:
      - postgres
    volumes:
      - flowise_data:/root/.flowise
    restart: unless-stopped
    networks:
      - flowise_network

volumes:
  postgres_data:
  flowise_data:

networks:
  flowise_network:
    driver: bridge

Inicia con:

docker-compose -f docker-compose.production.yml up -d

Script de Instalación Automática

Puedes usar este script para automatizar la instalación:

#!/bin/bash
# setup_flowise.sh

set -e

echo "🚀 Instalando Flowise..."

# Crear directorio de datos
mkdir -p /opt/flowise/data
chmod 755 /opt/flowise/data

# Copiar docker-compose.yml
if [ ! -f /opt/flowise/docker-compose.yml ]; then
    cp docker-compose.yml /opt/flowise/
    echo "✅ docker-compose.yml copiado"
fi

# Crear .env si no existe
if [ ! -f /opt/flowise/.env ]; then
    cat > /opt/flowise/.env <<'EOF'
FLOWISE_PASSWORD=changeme
POSTGRES_PASSWORD=changeme
EOF
    echo "✅ .env creado (cambiar passwords!)"
fi

# Iniciar Flowise
cd /opt/flowise
docker-compose up -d

echo ""
echo "✅ Flowise instalado en http://localhost:3000"
echo "📝 Usuario: admin"
echo "🔑 Password: changeme (cambiar en .env)"
echo ""
echo "Para producción, usar: docker-compose -f docker-compose.production.yml up -d"

—

Configuración Avanzada

Variables de Entorno

Flowise soporta múltiples variables de entorno para personalizar su comportamiento:

# Puerto (por defecto: 3000)
PORT=3000

# Credenciales
FLOWISE_USERNAME=admin
FLOWISE_PASSWORD=tu_password_seguro

# Base de datos (SQLite por defecto, PostgreSQL para producción)
DATABASE_PATH=postgresql://user:pass@postgres:5432/flowise

# Secret key para encriptación
SECRETKEY_PATH=/root/.flowise/.flowise

# Dependencias opcionales
TOOL_FUNCTION_BUILTIN_DEP=zod-to-json-schema

# Logging
LOG_LEVEL=info
LOG_PATH=/root/.flowise/logs
DEBUG=false

Persistencia de Datos

Con SQLite (por defecto):

Los datos se guardan en /root/.flowise dentro del contenedor. Asegúrate de montar este volumen:

volumes:
  - flowise_data:/root/.flowise

Con PostgreSQL (producción):

Los datos se guardan en PostgreSQL, permitiendo múltiples instancias y mejor rendimiento:

environment:
  - DATABASE_PATH=postgresql://flowise:changeme@postgres:5432/flowise

Seguridad

1. Cambiar credenciales por defecto:

Nunca uses admin/changeme en producción. Cambia las credenciales en .env:

FLOWISE_USERNAME=tu_usuario
FLOWISE_PASSWORD=tu_password_seguro

2. Usar reverse proxy:

Configura Traefik o Nginx con SSL delante de Flowise:

# Traefik labels
labels:
  - "traefik.enable=true"
  - "traefik.http.routers.flowise.rule=Host(`flowise.tudominio.com`)"
  - "traefik.http.routers.flowise.tls.certresolver=letsencrypt"

3. Network isolation:

Aísla Flowise en una red Docker separada:

networks:
  flowise_network:
    driver: bridge
    internal: false  # Cambiar a true para aislar completamente

—

Crear tu Primer Flujo RAG

Ahora que tienes Flowise instalado, vamos a crear tu primer flujo RAG. Este ejemplo creará un chatbot que responde preguntas sobre documentos PDF.

Paso 1: Acceder a Flowise

1. Abre http://localhost:3000 en tu navegador
2. Inicia sesión con admin / changeme
3. Verás el dashboard de Flowise

Paso 2: Crear un Nuevo Flujo

1. Haz clic en «New Flow» o «Crear Flujo»
2. Verás un canvas vacío donde construirás tu flujo

Paso 3: Añadir Componentes

1. Document Loader (PDF):

• Arrastra el nodo «Document Loader» al canvas
• Selecciona «PDF» como tipo
• Configura la ruta a tus PDFs (puedes subirlos desde la UI)

2. Text Splitter:

• Arrastra «Text Splitter» al canvas
• Conecta el output del Document Loader al input del Text Splitter
• Configura:

– chunkSize: 1000 (tamaño de cada chunk)

– chunkOverlap: 200 (solapamiento entre chunks)

3. Embeddings:

• Arrastra «Embeddings» al canvas
• Conecta el output del Text Splitter al input de Embeddings
• Selecciona el modelo de embeddings (ej: all-MiniLM-L6-v2)

4. Vector Store:

• Arrastra «Vector Store» al canvas
• Conecta el output de Embeddings al input de Vector Store
• Selecciona Qdrant, ChromaDB, o la DB que prefieras
• Configura la conexión

5. Retrieval QA Chain:

• Arrastra «Retrieval QA Chain» al canvas
• Conecta el Vector Store al input de la chain
• Selecciona el LLM (Ollama, LocalAI, OpenAI, etc.)
• Configura el modelo

Paso 4: Probar el Flujo

1. Haz clic en «Chat» en la parte superior
2. Escribe una pregunta sobre tus documentos
3. El flujo ejecutará: búsqueda en vector DB → recuperación de contexto → generación de respuesta

Ejemplo de Flujo Completo

[Document Loader (PDF)] 
    ↓
[Text Splitter (1000/200)]
    ↓
[Embeddings (all-MiniLM-L6-v2)]
    ↓
[Vector Store (Qdrant)]
    ↓
[Retrieval QA Chain (Ollama/llama3.2)]
    ↓
[Chat Interface]

—

Integración con Ollama/LocalAI

Flowise soporta LLMs locales a través de Ollama y LocalAI. Esto te permite ejecutar RAG completamente offline en tu homelab.

Integración con Ollama

1. Asegúrate de que Ollama está corriendo:

docker ps | grep ollama
# O verificar: curl http://localhost:11434/api/tags

2. En Flowise UI:

• Añadir nodo «Chat Model»
• Seleccionar «Ollama» como provider
• Configurar:

– Base URL: http://ollama:11434 (si mismo Docker network) o http://host.docker.internal:11434

– Model: llama3.2, mistral, qwen2.5, etc.

– Temperature: 0.7 (ajustar según necesidad)

3. Verificar conexión:

• Probar con un mensaje simple en el chat de Flowise
• Si falla, verificar red Docker o usar host.docker.internal

Integración con LocalAI

LocalAI es compatible con la API de OpenAI, por lo que puedes usarlo como provider «OpenAI» en Flowise:

1. Configurar LocalAI:

# docker-compose.yml
services:
  localai:
    image: localai/localai:latest
    ports:
      - "8080:8080"

2. En Flowise UI:

• Añadir nodo «Chat Model»
• Seleccionar «OpenAI» como provider (LocalAI es compatible)
• Configurar:

– Base URL: http://localai:8080/v1

– API Key: not-needed (o cualquier string)

– Model: llama3, mistral, etc.

Ejemplo de Flujo RAG con Ollama

[Document Loader] → [Text Splitter] → [Embeddings] → [Vector Store] → [Retrieval QA Chain (Ollama)]

Este flujo ejecuta completamente local, sin enviar datos a servicios cloud.

—

Integración con Vector Databases

Flowise soporta múltiples vector databases. Aquí tienes cómo configurar las más populares:

Qdrant (Recomendado para Homelab)

Setup Qdrant:

# docker-compose.yml
services:
  qdrant:
    image: qdrant/qdrant:latest
    ports:
      - "6333:6333"
    volumes:
      - qdrant_data:/qdrant/storage

En Flowise:

1. Añadir nodo «Vector Store»
2. Seleccionar «Qdrant»
3. Configurar:

– URL: http://qdrant:6333 (Docker network) o http://localhost:6333

– Collection: Nombre de la colección (ej: documents)

ChromaDB (Simple, Python-first)

Setup ChromaDB:

services:
  chromadb:
    image: chromadb/chroma:latest
    ports:
      - "8000:8000"

En Flowise:

1. Seleccionar «ChromaDB» en Vector Store
2. URL: http://chromadb:8000

Pinecone (Cloud, Managed)

En Flowise:

1. Seleccionar «Pinecone»
2. Configurar API Key desde Pinecone dashboard
3. Seleccionar index

Comparativa de Vector Databases

—

Casos de Uso Prácticos

Caso 1: Chatbot con Documentos PDF

Objetivo: Crear un chatbot que responda preguntas sobre documentos PDF.

Flujo:

1. Document Loader (PDF) → Cargar documentos
2. Text Splitter → Dividir en chunks (1000 chars, overlap 200)
3. Embeddings (Ollama/LocalAI) → Generar embeddings
4. Vector Store (Qdrant) → Almacenar embeddings
5. Retrieval QA Chain → Responder preguntas

Resultado: Chatbot que responde preguntas sobre documentos PDF usando RAG local.

Caso 2: Q&A sobre Base de Conocimiento

Objetivo: Sistema de Q&A con memoria conversacional sobre base de conocimiento.

Flujo:

1. Document Loader (Markdown/Text) → Cargar KB
2. Text Splitter → Chunks
3. Embeddings → Vectorizar
4. Vector Store → Almacenar
5. Conversational Retrieval Chain → Chat con memoria

Resultado: Sistema Q&A con memoria conversacional sobre base de conocimiento.

Caso 3: Búsqueda Semántica

Objetivo: Búsqueda semántica mejorada con re-ranking.

Flujo:

1. Query → Pregunta del usuario
2. Embeddings → Vectorizar query
3. Vector Store → Búsqueda similaridad
4. Re-ranking → Ordenar resultados
5. LLM → Generar respuesta contextual

Resultado: Búsqueda semántica mejorada con re-ranking.

—

Troubleshooting Común

Error: «Cannot connect to Ollama»

Causa: Ollama no está accesible desde el contenedor Flowise.

Solución:

# docker-compose.yml
services:
  flowise:
    # ...
    extra_hosts:
      - "host.docker.internal:host-gateway"
    # O usar network_mode: host

Error: «Vector database connection failed»

Causa: Vector DB no está configurada correctamente.

Solución:

1. Verificar que Qdrant/Pinecone está corriendo
2. Verificar credenciales en Flowise
3. Verificar red Docker (mismo network)

Error: «Out of memory» al procesar documentos grandes

Causa: Documentos muy grandes sin chunking adecuado.

Solución:

1. Reducir chunkSize en Text Splitter
2. Aumentar chunkOverlap para mejor contexto
3. Procesar documentos en lotes

Error: «LLM timeout»

Causa: LLM local (Ollama/LocalAI) tarda demasiado.

Solución:

1. Usar modelos más pequeños
2. Aumentar timeout en configuración
3. Verificar recursos GPU/CPU

—

Mejores Prácticas

Seguridad

1. Cambiar credenciales por defecto: Nunca usar admin/changeme en producción
2. Variables de entorno: Usar .env para secrets
3. Reverse proxy: Usar Traefik/Nginx con SSL
4. Network isolation: Aislar Flowise en red Docker separada
5. Backups: Hacer backup regular de /root/.flowise

Escalabilidad

1. PostgreSQL: Usar PostgreSQL en lugar de SQLite para producción
2. Vector DB externa: Usar Qdrant/Pinecone externo para múltiples instancias
3. Load balancer: Usar Nginx/Traefik para balancear carga
4. Caching: Implementar cache de embeddings y respuestas

Optimización

1. Chunk size: Optimizar tamaño de chunks según tipo de documento
2. Embeddings: Usar modelos de embeddings eficientes (all-MiniLM-L6-v2)
3. Batch processing: Procesar documentos en lotes
4. Monitoring: Monitorear uso de recursos (CPU, RAM, GPU)

—

📦 Descargar Ejemplos

Todos los ejemplos de código, configuraciones Docker, y scripts de este artículo están disponibles en GitHub:

🔗 Repositorio: https://github.com/ziruelen/learningaiagents/tree/main/flowise/flowise-framework-rag-sin-codigo-homelab-guia-completa-2026

Incluye:

• docker-compose.yml – Configuración básica
• docker-compose.production.yml – Configuración producción con PostgreSQL
• scripts/setup_flowise.sh – Script de instalación automática
• configs/flowise.env – Variables de entorno ejemplo
• docs/integracion-ollama.md – Guía integración Ollama
• docs/integracion-vectordb.md – Guía integración vector DBs

—

Enlaces Relacionados

• Dify.AI: Framework LLM sin Código para Homelab
• LangChain vs LlamaIndex: Framework RAG para Homelab
• LocalAI: Cliente OpenAI Compatible 100% Local
• AnythingLLM: RAG Local sin Código en tu Homelab

—

Preguntas Frecuentes

¿Flowise es gratuito?

Sí, Flowise es completamente gratuito y open-source bajo licencia MIT. No hay límites de uso ni versiones premium.

¿Puedo usar Flowise sin conexión a internet?

Sí, si usas LLMs locales (Ollama, LocalAI) y vector databases locales (Qdrant, ChromaDB), Flowise funciona completamente offline.

¿Flowise soporta múltiples usuarios?

Sí, Flowise soporta múltiples usuarios. Puedes crear usuarios adicionales desde la interfaz de administración.

¿Puedo exportar flujos de Flowise a código LangChain?

Sí, Flowise permite exportar flujos como código LangChain. Esto es útil si quieres migrar a código más adelante.

¿Qué diferencia hay entre Flowise y Dify.AI?

Flowise es más visual y flexible (drag-and-drop puro), mientras que Dify.AI es más estructurado con templates predefinidos. Flowise es mejor para prototipado rápido y máxima flexibilidad.

¿Flowise funciona con GPU?

Flowise en sí no requiere GPU, pero los LLMs locales (Ollama, LocalAI) sí pueden usar GPU para acelerar la inferencia.

¿Puedo integrar Flowise con n8n?

Sí, Flowise expone una API REST que puedes usar desde n8n con el nodo HTTP Request.

¿Qué vector database recomiendas para homelab?

Qdrant es la mejor opción para homelab: fácil de instalar, rápida, y self-hosted. ChromaDB es más simple pero menos escalable.

¿Flowise guarda mis documentos?

No, Flowise solo guarda los embeddings y metadatos en la vector database. Los documentos originales no se almacenan en Flowise.

¿Puedo usar Flowise con OpenAI?

Sí, Flowise soporta OpenAI, Anthropic, Google, y otros LLMs cloud. Solo necesitas configurar tu API key.

¿Flowise es seguro para datos sensibles?

Flowise es open-source, lo que significa que puedes auditar el código. Para datos sensibles, usa LLMs locales (Ollama, LocalAI) y vector databases locales (Qdrant) para mantener todo offline.

¿Qué requisitos de hardware tiene Flowise?

Flowise en sí es ligero (512MB RAM), pero los LLMs locales (Ollama, LocalAI) requieren más recursos según el modelo. Para modelos pequeños (7B), 8GB RAM es suficiente. Para modelos grandes (70B), necesitas 64GB+ RAM o GPU.

¿Puedo usar Flowise en producción?

Sí, Flowise es adecuado para producción. Usa PostgreSQL en lugar de SQLite, configura un reverse proxy con SSL, y sigue las mejores prácticas de seguridad.

¿Flowise soporta múltiples idiomas?

Sí, Flowise soporta múltiples idiomas. Los LLMs (Ollama, LocalAI) determinan el idioma de las respuestas.

¿Cómo hago backup de mis flujos en Flowise?

Los flujos se guardan en la base de datos (SQLite o PostgreSQL). Haz backup de la base de datos regularmente. También puedes exportar flujos individuales como JSON desde la UI.

—

Conclusión

Flowise es una herramienta poderosa para crear sistemas RAG sin escribir código. Con su interfaz visual drag-and-drop, puedes construir flujos complejos en minutos, integrando LLMs locales (Ollama, LocalAI) y vector databases (Qdrant, ChromaDB) para mantener todo en tu homelab.

Próximos pasos:

1. Instala Flowise usando el docker-compose.yml de los ejemplos
2. Crea tu primer flujo RAG siguiendo el tutorial paso a paso
3. Integra con Ollama para LLMs locales
4. Conecta con Qdrant para vector database local
5. Explora casos de uso avanzados: chatbot con documentos, Q&A sobre PDFs, búsqueda semántica

¿Necesitas ayuda?

• Revisa los ejemplos en GitHub
• Consulta la documentación oficial de Flowise
• Únete a la comunidad de Flowise en Discord

¿Has probado Flowise? ¿Qué flujos RAG has creado? Comparte tu experiencia en los comentarios.