AnythingLLM 与 RAGFlow 的区别分析

核心定位

• AnythingLLM：全栈私有化方案，强调数据100%本地化，注重企业级权限管理，通过多用户模式和工作区隔离，适合对数据隐私要求极高的场景（如法律案例库、制造业工艺文档管理等）。
• RAGFlow：企业级复杂文档处理专家，旨在通过深度文档理解技术，解决现有RAG技术在数据处理和生成答案方面的挑战，更适合处理法律合同审查、医疗报告分析等复杂文档场景。

文档处理能力

• AnythingLLM：支持200多种文档格式，可处理PDF、TXT、DOCX等常见文档，能提取文本信息并保存到向量数据库。
• RAGFlow：侧重于复杂格式文档处理（如扫描件、表格、影印件等），具备深度文档理解能力，可识别文档布局、表格单元格等细节。

检索精度

• AnythingLLM：采用常规向量检索方式。
• RAGFlow：通过多路召回+LLM重排序优化，能实现高精度检索，在处理复杂文档时，更准确地召回相关信息。

模型支持

• AnythingLLM：支持本地/云端模型混合部署，可对接主流大模型，包括本地私有大模型（如Llama 2）、OpenAI、Azure OpenAI和百度千帆大模型等。
• RAGFlow：依赖内置RAG流程，支持30多种开源模型，主要通过分层模块化架构，支持向量数据库的灵活替换与Embedding模型的自由选型。

AnythingLLM安装：https://blog.csdn.net/YXWik/article/details/149804171

本文脚本总结：将docker-compose-linux-x86_64 +RagFlow项目 +install_ragflow.sh 进行安装

github代理站：https://g.cachecdn.ggff.net/
下载docker-compose-linux-x86_64：https://github.com/docker/compose/releases/download/v2.29.2/docker-compose-Linux-x86_64

下载RagFlow项目：https://github.com/infiniflow/ragflow/archive/refs/heads/main.zip

上传到服务器进行解压

进入项目的docker目录下

cd /ragflow-main/docker

将以下两个文件放到docker目录下
install_ragflow.sh脚本+docker-compose-linux-x86_64（Docker Compose）

install_ragflow.sh
脚本记得赋权
为避免ragflow的端口冲突，我在脚本中设置了端口为8880开始检测，如果没占用采用8880进行web端访问端口

#!/bin/bash

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'

# 基础配置
BASE_ES_PORT=1201
BASE_MYSQL_PORT=5456
BASE_REDIS_PORT=6380
BASE_MINIO_PORT=9002
BASE_MINIO_CONSOLE_PORT=9003
BASE_SVR_HTTP_PORT=9300
BASE_WEB_HTTP_PORT=8880

# 容器名称（必须与docker-compose中一致）
CONTAINER_PREFIX="ragflow"
SERVER_CONTAINER="${CONTAINER_PREFIX}-server"
MYSQL_CONTAINER="${CONTAINER_PREFIX}-mysql"
REDIS_CONTAINER="${CONTAINER_PREFIX}-redis"
ES_CONTAINER="${CONTAINER_PREFIX}-es-01"
MINIO_CONTAINER="${CONTAINER_PREFIX}-minio"
CONTAINERS=("$SERVER_CONTAINER" "$MYSQL_CONTAINER" "$REDIS_CONTAINER" "$ES_CONTAINER" "$MINIO_CONTAINER")

# 核心路径与密码
RAGFLOW_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
MYSQL_PASSWORD="infini_rag_flow"
COMPOSE_VERSION="v2.29.2"

# 1. 检测可用端口
get_available_port() {
  local base_port=$1
  local port=$base_port
  while netstat -tulpn | awk '{print $4}' | grep -q ":$port$"; do
    port=$((port + 1))
  done
  echo $port
}

# 2. 环境检查
check_env() {
  echo -e "${YELLOW}检查环境...${NC}"
  if [ "$EUID" -ne 0 ]; then
    echo -e "${RED}错误：请使用root权限运行${NC}" && exit 1
  fi
  if ! command -v docker &> /dev/null; then
    echo -e "${RED}错误：未检测到Docker${NC}" && exit 1
  fi
  if ! command -v docker-compose &> /dev/null; then
    echo -e "${YELLOW}Docker Compose未安装，将自动安装${NC}"
  fi
  if ! command -v netstat &> /dev/null; then
    echo -e "${YELLOW}安装端口检测工具...${NC}"
    yum install -y net-tools &> /dev/null || { echo -e "${RED}安装net-tools失败${NC}"; exit 1; }
  fi
  echo -e "${GREEN}环境检查通过${NC}"
}

# 3. 获取所有端口
get_ports() {
  ES_PORT=$(get_available_port $BASE_ES_PORT)
  MYSQL_PORT=$(get_available_port $BASE_MYSQL_PORT)
  REDIS_PORT=$(get_available_port $BASE_REDIS_PORT)
  MINIO_PORT=$(get_available_port $BASE_MINIO_PORT)
  
  # 确保MinIO控制台端口不冲突
  MINIO_CONSOLE_PORT=$(get_available_port $BASE_MINIO_CONSOLE_PORT)
  while [ "$MINIO_CONSOLE_PORT" -eq "$MINIO_PORT" ]; do
    MINIO_CONSOLE_PORT=$((MINIO_CONSOLE_PORT + 1))
  done
  
  SVR_HTTP_PORT=$(get_available_port $BASE_SVR_HTTP_PORT)
  WEB_HTTP_PORT=$(get_available_port $BASE_WEB_HTTP_PORT)
}

# 4. 打印端口信息
print_ports() {
  echo -e "${YELLOW}检测到可用端口：${NC}"
  echo -e "Elasticsearch: $ES_PORT"
  echo -e "MySQL: $MYSQL_PORT"
  echo -e "Redis: $REDIS_PORT"
  echo -e "MinIO（主端口）: $MINIO_PORT"
  echo -e "MinIO（控制台）: $MINIO_CONSOLE_PORT"
  echo -e "RAGFlow服务（API）: $SVR_HTTP_PORT"
  echo -e "RAGFlow服务（Web）: $WEB_HTTP_PORT"
}

# 5. 安装Docker Compose
install_compose() {
  echo -e "${YELLOW}安装Docker Compose...${NC}"
  COMPOSE_BIN="/usr/local/bin/docker-compose"
  
  if ! command -v docker-compose &> /dev/null; then
    if [ -f "$RAGFLOW_DIR/docker-compose-linux-x86_64" ]; then
      cp "$RAGFLOW_DIR/docker-compose-linux-x86_64" "$COMPOSE_BIN"
    else
      if ! curl -L "https://github.com/docker/compose/releases/download/$COMPOSE_VERSION/docker-compose-Linux-x86_64" -o "$COMPOSE_BIN"; then
        echo -e "${RED}错误：Docker Compose下载失败${NC}" && exit 1
      fi
    fi
    chmod +x "$COMPOSE_BIN"
  fi
  
  if ! command -v docker-compose &> /dev/null; then
    echo -e "${RED}错误：Docker Compose安装失败${NC}" && exit 1
  fi
  echo -e "${GREEN}Docker Compose安装成功${NC}"
}

# 6. 生成所有配置文件（含mapping.json）
generate_configs() {
  echo -e "${YELLOW}生成所有配置文件（含缺失文件）...${NC}"
  mkdir -p "$RAGFLOW_DIR/conf" "$RAGFLOW_DIR/nginx" && cd "$RAGFLOW_DIR" || exit 1
  
  # 清理旧配置
  rm -rf init.sql docker-compose.yml .env
  
  # 生成.env文件
  cat > .env <<EOF
SERVER_CONTAINER=${SERVER_CONTAINER}
MYSQL_CONTAINER=${MYSQL_CONTAINER}
REDIS_CONTAINER=${REDIS_CONTAINER}
ES_CONTAINER=${ES_CONTAINER}
MINIO_CONTAINER=${MINIO_CONTAINER}
DOC_ENGINE=elasticsearch
COMPOSE_PROFILES=${DOC_ENGINE}
STACK_VERSION=8.11.3
ES_HOST=es01
ES_PORT=1200
ES_USER=elastic
ELASTIC_PASSWORD=infini_rag_flow
KIBANA_PORT=6601
KIBANA_USER=rag_flow
KIBANA_PASSWORD=infini_rag_flow
MEM_LIMIT=8073741824
INFINITY_HOST=infinity
INFINITY_THRIFT_PORT=23817
INFINITY_HTTP_PORT=23820
INFINITY_PSQL_PORT=5432
MYSQL_PASSWORD=infini_rag_flow
MYSQL_HOST=mysql
MYSQL_DBNAME=rag_flow
MYSQL_PORT=$MYSQL_PORT
MINIO_HOST=minio
MINIO_CONSOLE_PORT=$MINIO_CONSOLE_PORT
MINIO_PORT=$MINIO_PORT
MINIO_USER=rag_flow
MINIO_PASSWORD=infini_rag_flow
REDIS_HOST=redis
REDIS_PORT=$REDIS_PORT
REDIS_PASSWORD=infini_rag_flow
SVR_HTTP_PORT=$SVR_HTTP_PORT
RAGFLOW_IMAGE=swr.cn-north-4.myhuaweicloud.com/infiniflow/ragflow:nightly
TIMEZONE="Asia/Shanghai"
HF_ENDPOINT=https://hf-mirror.com
REGISTER_ENABLED=1
WEB_HTTP_PORT=$WEB_HTTP_PORT
EOF

  # 生成docker-compose.yml（确保容器名称正确）
  cat > docker-compose.yml <<EOF
services:
  ragflow:
    image: '\${RAGFLOW_IMAGE}'
    container_name: ragflow-server
    ports:
      - '\${SVR_HTTP_PORT}:9380'
      - '\${WEB_HTTP_PORT}:80'
      - 443:443
      - 5678:5678
      - 5679:5679
    depends_on:
      mysql:
        condition: service_healthy
    environment:
      - MYSQL_HOST='\$MYSQL_CONTAINER'
      - REDIS_HOST='\$REDIS_CONTAINER'
      - ES_HOST='\$ES_CONTAINER'
      - MINIO_HOST='\$MINIO_CONTAINER'
      - MYSQL_PASSWORD=infini_rag_flow
      - TZ="Asia/Shanghai"
      - HF_ENDPOINT='\${HF_ENDPOINT}'
      - MACOS='\${MACOS}'
    volumes:
      - ./ragflow-logs:/ragflow/logs
      - ./nginx/ragflow.conf:/etc/nginx/conf.d/ragflow.conf
      - ./nginx/proxy.conf:/etc/nginx/proxy.conf
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - ../history_data_agent:/ragflow/history_data_agent  
      - ./service_conf.yaml.template:/ragflow/conf/service_conf.yaml.template
      
    env_file: .env      
    networks:
      - ragflow
    restart: on-failure
    extra_hosts:
      - "host.docker.internal:host-gateway"
      
  es01:
    container_name: ragflow-es-01
    profiles:
      - elasticsearch
    image: 'elasticsearch:\${STACK_VERSION}'
    volumes:
      - esdata01:/usr/share/elasticsearch/data
    ports:
      - '\${ES_PORT}:9200'
    env_file: .env
    environment:
      - node.name=es01
      - ELASTIC_PASSWORD=infini_rag_flow
      - bootstrap.memory_lock=false
      - discovery.type=single-node
      - xpack.security.enabled=true
      - xpack.security.http.ssl.enabled=false
      - xpack.security.transport.ssl.enabled=false
      - cluster.routing.allocation.disk.watermark.low=5gb
      - cluster.routing.allocation.disk.watermark.high=3gb
      - cluster.routing.allocation.disk.watermark.flood_stage=2gb
      - TZ="Asia/Shanghai"
    mem_limit: 8073741824
    ulimits:
      memlock:
        soft: -1
        hard: -1
    healthcheck:
      test: ["CMD-SHELL", "curl http://localhost:9200"]
      interval: 10s
      timeout: 10s
      retries: 120
    networks:
      - ragflow
    restart: on-failure

  infinity:
    container_name: ragflow-infinity
    profiles:
      - infinity
    image: infiniflow/infinity:v0.6.0-dev3
    volumes:
      - infinity_data:/var/infinity
      - ./infinity_conf.toml:/infinity_conf.toml
    command: ["-f", "/infinity_conf.toml"]
    ports:
      - '\${INFINITY_THRIFT_PORT}:23817'
      - '\${INFINITY_HTTP_PORT}:23820'
      - '\${INFINITY_PSQL_PORT}:5432'
    env_file: .env
    environment:
      - TZ="Asia/Shanghai"
    mem_limit: 8073741824
    ulimits:
      nofile:
        soft: 500000
        hard: 500000
    networks:
      - ragflow
    healthcheck:
      test: ["CMD", "curl", "http://localhost:23820/admin/node/current"]
      interval: 10s
      timeout: 10s
      retries: 120
    restart: on-failure


  mysql:
    # mysql:5.7 linux/arm64 image is unavailable.
    image: mysql:8.0.39
    container_name: ragflow-mysql
    env_file: .env
    environment:
      - "MYSQL_ROOT_PASSWORD=infini_rag_flow"
      - '\TZ=${TIMEZONE}'
    command:
      --max_connections=1000
      --character-set-server=utf8mb4
      --collation-server=utf8mb4_unicode_ci
      --default-authentication-plugin=mysql_native_password
      --tls_version="TLSv1.2,TLSv1.3"
      --init-file /data/application/init.sql
      --binlog_expire_logs_seconds=604800
    ports:
      - '\${MYSQL_PORT}:3306'
    volumes:
      - mysql_data:/var/lib/mysql
      - ./init.sql:/data/application/init.sql
    networks:
      - ragflow
    healthcheck:
      test: ["CMD", "mysqladmin" ,"ping", "-uroot", "-pinfini_rag_flow"]
      interval: 10s
      timeout: 10s
      retries: 3
    restart: on-failure

  minio:
    image: quay.io/minio/minio:RELEASE.2023-12-20T01-00-02Z
    container_name: ragflow-minio
    command: server --console-address ":9001" /data
    ports:
      - '\${MINIO_PORT}:9000'
      - '\${MINIO_CONSOLE_PORT}:9001'
    env_file: .env
    environment:
      - MINIO_ROOT_USER=rag_flow
      - MINIO_ROOT_PASSWORD=infini_rag_flow
      - TZ="Asia/Shanghai"
    volumes:
      - minio_data:/data
    networks:
      - ragflow
    restart: on-failure
    
  redis:
    image: valkey/valkey:8
    container_name: ragflow-redis
    entrypoint: ["redis-server", "--requirepass", "infini_rag_flow", "--maxmemory", "128mb", "--maxmemory-policy", "allkeys-lru"]
    env_file: .env
    ports:
      - '\${REDIS_PORT}:6379'
    volumes:
      - redis_data:/data
    networks:
      - ragflow
    restart: on-failure
    
volumes:
  esdata01:
    driver: local
  infinity_data:
    driver: local
  mysql_data:
    driver: local
  minio_data:
    driver: local
  redis_data:
    driver: local

networks:
  ragflow:
    driver: bridge
EOF
  
  # 生成MySQL初始化脚本
  cat > init.sql <<EOF
CREATE DATABASE IF NOT EXISTS rag_flow CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
EOF

 cat > service_conf.yaml.template <<EOF
ragflow:
  host: ${RAGFLOW_HOST:-0.0.0.0}  # 去掉单引号，变量直接引用
  http_port: 9380
mysql:
  name: ${MYSQL_DBNAME:-rag_flow}
  user: ${MYSQL_USER:-root}
  password: ${MYSQL_PASSWORD:-infini_rag_flow}
  host: ${MYSQL_HOST:-mysql}
  port: 3306
  max_connections: 900
  stale_timeout: 300
minio:
  user: ${MINIO_USER:-rag_flow}
  password: ${MINIO_PASSWORD:-infini_rag_flow}
  host: ${MINIO_HOST:-minio}:9000
es:
  hosts: http://${ES_HOST:-es01}:9200
  username: ${ES_USER:-elastic}
  password: ${ELASTIC_PASSWORD:-infini_rag_flow}
os:
  hosts: http://${OS_HOST:-opensearch01}:9201
  username: ${OS_USER:-admin}
  password: ${OPENSEARCH_PASSWORD:-infini_rag_flow_OS_01}
infinity:
  uri: ${INFINITY_HOST:-infinity}:23817
  db_name: default_db
redis:
  db: 1
  password: ${REDIS_PASSWORD:-infini_rag_flow}
  host: ${REDIS_HOST:-redis}:6379
  
EOF




  echo -e "${GREEN}所有配置文件生成完成（含mapping.json）${NC}"
}

# 7. 启动服务
start_services() {
  echo -e "${YELLOW}清理旧容器...${NC}"
  for container in "${CONTAINERS[@]}"; do
    if docker ps -a --format "{{.Names}}" | grep -q "^$container$"; then
      docker rm -f "$container" &> /dev/null
      echo -e "已删除旧容器：$container"
    fi
  done

  echo -e "${YELLOW}启动所有服务...${NC}"
  cd "$RAGFLOW_DIR" || exit 1
 
  docker-compose --profile elasticsearch up -d
  
  echo -e "${YELLOW}等待服务就绪（30秒）...${NC}"
  sleep 30
  
 
}

# 8. 修复MySQL授权
fix_mysql_authorization() {
  echo -e "${YELLOW}修复MySQL授权...${NC}"
  if docker ps --format "{{.Names}}" | grep -q "^$MYSQL_CONTAINER$"; then
    docker exec "$MYSQL_CONTAINER" sh -c "
      mysql -uroot -pinfini_rag_flow -e \"
        CREATE USER IF NOT EXISTS 'root'@'%' IDENTIFIED BY 'infini_rag_flow';
        GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' WITH GRANT OPTION;
        FLUSH PRIVILEGES;
      \"
    "
    echo -e "${GREEN}MySQL授权修复完成${NC}"
  else
    echo -e "${RED}错误：$MYSQL_CONTAINER未启动，授权修复失败${NC}"
  fi
}

# 9. 验证安装
verify_installation() {
  SERVER_IP=$(hostname -I | awk '{print $1}')
  
  # 检查服务是否运行
  if ! docker ps --format "{{.Names}}" | grep -q "^$SERVER_CONTAINER$"; then
    echo -e "${RED}错误：$SERVER_CONTAINER未正常启动${NC}"
    echo -e "${YELLOW}服务日志：${NC}"
    docker logs "$SERVER_CONTAINER" 2>&1 | head -30
    exit 1
  fi
  
  # 检查关键错误
  if docker logs "$SERVER_CONTAINER" 2>&1 | grep -q "Error"; then
    echo -e "${YELLOW}服务存在错误日志：${NC}"
    docker logs "$SERVER_CONTAINER" 2>&1 | grep "Error" | head -10
  fi
  
  echo -e "${GREEN}===== 安装成功！====="
  echo -e "Web访问地址：http://$SERVER_IP:$WEB_HTTP_PORT"
  echo -e "API访问地址：http://$SERVER_IP:$SVR_HTTP_PORT"
}

# 主流程
main() {
  echo -e "${GREEN}===== RAGFlow安装脚本（终极修复版）=====${NC}"
  
  check_env
  get_ports
  print_ports
  install_compose
  generate_configs
  start_services
  fix_mysql_authorization
  verify_installation
  
  echo -e "${GREEN}===== 安装流程完成 ====="
}

# 执行主函数
main

脚本会在docker中安装 redis 、 minio 、 es 、mysql 、ragflow ，如果服务器存在这些服务的记得处理下，

运行脚本

./install_ragflow.sh

如果重复运行脚本就需要执行以下命令进行清理后再重启

docker volume ls | grep data
docker volume rm  指定data
docker stop ragflow-server ragflow-minio ragflow-mysql ragflow-es-01 ragflow-redis
docker rm ragflow-server ragflow-minio ragflow-mysql ragflow-es-01 ragflow-redis

Linux安装docker+ollama+deepseek：https://blog.csdn.net/YXWik/article/details/149497501

设置模型，前文中安装了deepseek-r1:7b

http://host.docker.internal:11434/

设置聊天默认模型

创建知识库

Windows安装ragflow：https://blog.csdn.net/YXWik/article/details/147122723

切换文档引擎：

从Elasticsearch到Infinity
RAGFlow默认用Elasticsearch存储文本和向量，若需切换到高效向量数据库Infinity

更改 .env文件中的配置 DOC_ENGINE=infinity 重启 ，或者更改install_ragflow.sh 中的DOC_ENGINE