将flask改成fastapi

2025-10-13 13:18:03 +08:00
commit 88db2539b0
476 changed files with 739741 additions and 0 deletions
--- a/intergrations/chatgpt-on-wechat/plugins/README.md
+++ b/intergrations/chatgpt-on-wechat/plugins/README.md
@@ -0,0 +1,57 @@
+RAGFlow Chat Plugin for ChatGPT-on-WeChat
+=========================================
+
+This folder contains the source code for the `ragflow_chat` plugin, which extends the core functionality of the RAGFlow API to support conversational interactions using Retrieval-Augmented Generation (RAG). This plugin integrates seamlessly with the [ChatGPT-on-WeChat](https://github.com/zhayujie/chatgpt-on-wechat) project, enabling WeChat and other platforms to leverage the knowledge retrieval capabilities provided by RAGFlow in chat interactions.
+
+### Features
+* **Conversational Interactions**: Combine WeChat's conversational interface with powerful RAG (Retrieval-Augmented Generation) capabilities.
+* **Knowledge-Based Responses**: Enrich conversations by retrieving relevant data from external knowledge sources and incorporating them into chat responses.
+* **Multi-Platform Support**: Works across WeChat, WeCom, and various other platforms supported by the ChatGPT-on-WeChat framework.
+
+### Plugin vs. ChatGPT-on-WeChat Configurations
+**Note**: There are two distinct configuration files used in this setup—one for the ChatGPT-on-WeChat core project and another specific to the `ragflow_chat` plugin. It is important to configure both correctly to ensure smooth integration.
+
+#### ChatGPT-on-WeChat Root Configuration (`config.json`)
+This file is located in the root directory of the [ChatGPT-on-WeChat](https://github.com/zhayujie/chatgpt-on-wechat) project and is responsible for defining the communication channels and overall behavior. For example, it handles the configuration for WeChat, WeCom, and other services like Feishu and DingTalk.
+
+Example `config.json` (for WeChat channel):
+```json
+{
+  "channel_type": "wechatmp",
+  "wechatmp_app_id": "YOUR_APP_ID",
+  "wechatmp_app_secret": "YOUR_APP_SECRET",
+  "wechatmp_token": "YOUR_TOKEN",
+  "wechatmp_port": 80,
+  ...
+}
+```
+
+This file can also be modified to support other communication platforms, such as:
+- **Personal WeChat** (`channel_type: wx`)
+- **WeChat Public Account** (`wechatmp` or `wechatmp_service`)
+- **WeChat Work (WeCom)** (`wechatcom_app`)
+- **Feishu** (`feishu`)
+- **DingTalk** (`dingtalk`)
+
+For detailed configuration options, see the official [LinkAI documentation](https://docs.link-ai.tech/cow/multi-platform/wechat-mp).
+
+#### RAGFlow Chat Plugin Configuration (`plugins/ragflow_chat/config.json`)
+This configuration is specific to the `ragflow_chat` plugin and is used to set up communication with the RAGFlow server. Ensure that your RAGFlow server is running, and update the plugin's `config.json` file with your server details:
+
+Example `config.json` (for `ragflow_chat`):
+```json
+{
+  "ragflow_api_key": "YOUR_API_KEY",
+  "ragflow_host": "127.0.0.1:80"
+}
+```
+
+This file must be configured to point to your RAGFlow instance, with the `ragflow_api_key` and `ragflow_host` fields set appropriately. The `ragflow_host` is typically your server's address and port number, and the `ragflow_api_key` is obtained from your RAGFlow API setup.
+
+### Requirements
+Before you can use this plugin, ensure the following are in place:
+
+1. You have installed and configured [ChatGPT-on-WeChat](https://github.com/zhayujie/chatgpt-on-wechat).
+2. You have deployed and are running the [RAGFlow](https://github.com/infiniflow/ragflow) server.
+   
+Make sure both `config.json` files (ChatGPT-on-WeChat and RAGFlow Chat Plugin) are correctly set up as per the examples above.
--- a/intergrations/chatgpt-on-wechat/plugins/init.py
+++ b/intergrations/chatgpt-on-wechat/plugins/init.py
@@ -0,0 +1,24 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+from beartype.claw import beartype_this_package
+beartype_this_package()
+
+from .ragflow_chat import RAGFlowChat
+
+__all__ = [
+    "RAGFlowChat"
+]
--- a/intergrations/chatgpt-on-wechat/plugins/config.json
+++ b/intergrations/chatgpt-on-wechat/plugins/config.json
@@ -0,0 +1,4 @@
+{
+    "api_key": "ragflow-***",
+    "host_address": "127.0.0.1:80"
+}
--- a/intergrations/chatgpt-on-wechat/plugins/ragflow_chat.py
+++ b/intergrations/chatgpt-on-wechat/plugins/ragflow_chat.py
@@ -0,0 +1,127 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+import logging
+import requests
+from bridge.context import ContextType  # Import Context, ContextType
+from bridge.reply import Reply, ReplyType  # Import Reply, ReplyType
+from plugins import Plugin, register  # Import Plugin and register
+from plugins.event import Event, EventContext, EventAction  # Import event-related classes
+
+@register(name="RAGFlowChat", desc="Use RAGFlow API to chat", version="1.0", author="Your Name")
+class RAGFlowChat(Plugin):
+    def __init__(self):
+        super().__init__()
+        # Load plugin configuration
+        self.cfg = self.load_config()
+        # Bind event handling function
+        self.handlers[Event.ON_HANDLE_CONTEXT] = self.on_handle_context
+        # Store conversation_id for each user
+        self.conversations = {}
+        logging.info("[RAGFlowChat] Plugin initialized")
+
+    def on_handle_context(self, e_context: EventContext):
+        context = e_context['context']
+        if context.type != ContextType.TEXT:
+            return  # Only process text messages
+
+        user_input = context.content.strip()
+        session_id = context['session_id']
+
+        # Call RAGFlow API to get a reply
+        reply_text = self.get_ragflow_reply(user_input, session_id)
+        if reply_text:
+            reply = Reply()
+            reply.type = ReplyType.TEXT
+            reply.content = reply_text
+            e_context['reply'] = reply
+            e_context.action = EventAction.BREAK_PASS  # Skip the default processing logic
+        else:
+            # If no reply is received, pass to the next plugin or default logic
+            e_context.action = EventAction.CONTINUE
+
+    def get_ragflow_reply(self, user_input, session_id):
+        # Get API_KEY and host address from the configuration
+        api_key = self.cfg.get("api_key")
+        host_address = self.cfg.get("host_address")
+        user_id = session_id  # Use session_id as user_id
+
+        if not api_key or not host_address:
+            logging.error("[RAGFlowChat] Missing configuration")
+            return "The plugin configuration is incomplete. Please check the configuration."
+
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+
+        # Step 1: Get or create conversation_id
+        conversation_id = self.conversations.get(user_id)
+        if not conversation_id:
+            # Create a new conversation
+            url_new_conversation = f"http://{host_address}/v1/api/new_conversation"
+            params_new_conversation = {
+                "user_id": user_id
+            }
+            try:
+                response = requests.get(url_new_conversation, headers=headers, params=params_new_conversation)
+                logging.debug(f"[RAGFlowChat] New conversation response: {response.text}")
+                if response.status_code == 200:
+                    data = response.json()
+                    if data.get("code") == 0:
+                        conversation_id = data["data"]["id"]
+                        self.conversations[user_id] = conversation_id
+                    else:
+                        logging.error(f"[RAGFlowChat] Failed to create conversation: {data.get('message')}")
+                        return f"Sorry, unable to create a conversation: {data.get('message')}"
+                else:
+                    logging.error(f"[RAGFlowChat] HTTP error when creating conversation: {response.status_code}")
+                    return f"Sorry, unable to connect to RAGFlow API (create conversation). HTTP status code: {response.status_code}"
+            except Exception as e:
+                logging.exception("[RAGFlowChat] Exception when creating conversation")
+                return f"Sorry, an internal error occurred: {str(e)}"
+
+        # Step 2: Send the message and get a reply
+        url_completion = f"http://{host_address}/v1/api/completion"
+        payload_completion = {
+            "conversation_id": conversation_id,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": user_input
+                }
+            ],
+            "quote": False,
+            "stream": False
+        }
+
+        try:
+            response = requests.post(url_completion, headers=headers, json=payload_completion)
+            logging.debug(f"[RAGFlowChat] Completion response: {response.text}")
+            if response.status_code == 200:
+                data = response.json()
+                if data.get("code") == 0:
+                    answer = data["data"]["answer"]
+                    return answer
+                else:
+                    logging.error(f"[RAGFlowChat] Failed to get answer: {data.get('message')}")
+                    return f"Sorry, unable to get a reply: {data.get('message')}"
+            else:
+                logging.error(f"[RAGFlowChat] HTTP error when getting answer: {response.status_code}")
+                return f"Sorry, unable to connect to RAGFlow API (get reply). HTTP status code: {response.status_code}"
+        except Exception as e:
+            logging.exception("[RAGFlowChat] Exception when getting answer")
+            return f"Sorry, an internal error occurred: {str(e)}"
--- a/intergrations/chatgpt-on-wechat/plugins/requirements.txt
+++ b/intergrations/chatgpt-on-wechat/plugins/requirements.txt
@@ -0,0 +1 @@
+requests
--- a/intergrations/extension_chrome/README.md
+++ b/intergrations/extension_chrome/README.md
@@ -0,0 +1,45 @@
+# Chrome Extension
+```
+chrome-extension/
+│
+├── manifest.json         # Main configuration file for the extension
+├── popup.html          # Main user interface of the extension
+├── popup.js            # Script for the main interface
+├── background.js       # Background script for the extension
+├── content.js          # Script to interact with web pages
+├── styles/
+│   └── popup.css       # CSS file for the popup
+├── icons/
+│   ├── icon16.png      # 16x16 pixel icon
+│   ├── icon48.png      # 48x48 pixel icon
+│   └── icon128.png     # 128x128 pixel icon
+├── assets/
+│   └── ...             # Directory for other assets (images, fonts, etc.)
+├── scripts/
+│   ├── utils.js        # File containing utility functions
+│   └── api.js          # File containing API call logic
+└── README.md           # Instructions for using and installing the extension
+```
+
+# Installation
+1. Open chrome://extensions/.
+2. Enable Developer mode.
+3. Click Load unpacked and select the project directory.
+# Features
+1. Interact with web pages.
+2. Run in the background to handle logic.
+# Usage
+- Click the extension icon in the toolbar.
+- Follow the instructions in the interface.
+# Additional Notes
+- **manifest.json**: This file is crucial as it defines the extension's metadata, permissions, and entry points.
+- **background.js**: This script runs independently of any web page and can perform tasks such as listening for browser events, making network requests, and storing data.
+- **content.js**: This script injects code into web pages to manipulate the DOM, modify styles, or communicate with the background script.
+- **popup.html/popup.js**: These files create the popup that appears when the user clicks the extension icon.
+icons: These icons are used to represent the extension in the browser's UI.
+More Detailed Explanation
+- **manifest.json**: Specifies the extension's name, version, permissions, and other details. It also defines the entry points for the background script, content scripts, and the popup.
+- **background.js**: Handles tasks that need to run continuously, such as syncing data, listening for browser events, or controlling the extension's behavior.
+- **content.js**: Interacts directly with the web page's DOM, allowing you to modify the content, style, or behavior of the page.
+- **popup.html/popup.js**: Creates a user interface that allows users to interact with the extension.
+Other files: These files can contain additional scripts, styles, or assets that are used by the extension.
--- a/intergrations/extension_chrome/assets/logo-with-text.png
+++ b/intergrations/extension_chrome/assets/logo-with-text.png
--- a/intergrations/extension_chrome/assets/logo.png
+++ b/intergrations/extension_chrome/assets/logo.png
--- a/intergrations/extension_chrome/assets/logo.svg
+++ b/intergrations/extension_chrome/assets/logo.svg
@@ -0,0 +1,29 @@
+<svg width="32" height="34" viewBox="0 0 32 34" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path fill-rule="evenodd" clip-rule="evenodd"
+        d="M3.43265 20.7677C4.15835 21.5062 4.15834 22.7035 3.43262 23.4419L3.39546 23.4797C2.66974 24.2182 1.49312 24.2182 0.767417 23.4797C0.0417107 22.7412 0.0417219 21.544 0.767442 20.8055L0.804608 20.7677C1.53033 20.0292 2.70694 20.0293 3.43265 20.7677Z"
+        fill="#B2DDFF" />
+    <path fill-rule="evenodd" clip-rule="evenodd"
+        d="M12.1689 21.3375C12.8933 22.0773 12.8912 23.2746 12.1641 24.0117L7.01662 29.2307C6.2896 29.9678 5.11299 29.9657 4.38859 29.2259C3.66419 28.4861 3.66632 27.2888 4.39334 26.5517L9.54085 21.3327C10.2679 20.5956 11.4445 20.5977 12.1689 21.3375Z"
+        fill="#53B1FD" />
+    <path fill-rule="evenodd" clip-rule="evenodd"
+        d="M19.1551 30.3217C19.7244 29.4528 20.8781 29.218 21.7321 29.7973L21.8436 29.8729C22.6975 30.4522 22.9283 31.6262 22.359 32.4952C21.7897 33.3641 20.6359 33.5989 19.782 33.0196L19.6705 32.944C18.8165 32.3647 18.5858 31.1907 19.1551 30.3217Z"
+        fill="#B2DDFF" />
+    <path fill-rule="evenodd" clip-rule="evenodd"
+        d="M31.4184 20.6544C32.1441 21.3929 32.1441 22.5902 31.4184 23.3286L28.8911 25.9003C28.1654 26.6388 26.9887 26.6388 26.263 25.9003C25.5373 25.1619 25.5373 23.9646 26.263 23.2261L28.7903 20.6544C29.516 19.916 30.6927 19.916 31.4184 20.6544Z"
+        fill="#53B1FD" />
+    <path fill-rule="evenodd" clip-rule="evenodd"
+        d="M31.4557 11.1427C32.1814 11.8812 32.1814 13.0785 31.4557 13.8169L12.7797 32.8209C12.054 33.5594 10.8774 33.5594 10.1517 32.8209C9.42599 32.0825 9.42599 30.8852 10.1517 30.1467L28.8277 11.1427C29.5534 10.4043 30.73 10.4043 31.4557 11.1427Z"
+        fill="#1570EF" />
+    <path fill-rule="evenodd" clip-rule="evenodd"
+        d="M27.925 5.29994C28.6508 6.0384 28.6508 7.23568 27.925 7.97414L17.184 18.9038C16.4583 19.6423 15.2817 19.6423 14.556 18.9038C13.8303 18.1653 13.8303 16.9681 14.556 16.2296L25.297 5.29994C26.0227 4.56148 27.1993 4.56148 27.925 5.29994Z"
+        fill="#1570EF" />
+    <path fill-rule="evenodd" clip-rule="evenodd"
+        d="M22.256 1.59299C22.9822 2.33095 22.983 3.52823 22.2578 4.26718L8.45055 18.3358C7.72533 19.0748 6.54871 19.0756 5.82251 18.3376C5.09631 17.5996 5.09552 16.4024 5.82075 15.6634L19.6279 1.59478C20.3532 0.855827 21.5298 0.855022 22.256 1.59299Z"
+        fill="#1570EF" />
+    <path fill-rule="evenodd" clip-rule="evenodd"
+        d="M8.58225 6.09619C9.30671 6.83592 9.30469 8.0332 8.57772 8.77038L3.17006 14.2541C2.4431 14.9913 1.26649 14.9893 0.542025 14.2495C-0.182438 13.5098 -0.180413 12.3125 0.546548 11.5753L5.95421 6.09159C6.68117 5.3544 7.85778 5.35646 8.58225 6.09619Z"
+        fill="#53B1FD" />
+    <path fill-rule="evenodd" clip-rule="evenodd"
+        d="M11.893 0.624023C12.9193 0.624023 13.7513 1.47063 13.7513 2.51497V2.70406C13.7513 3.7484 12.9193 4.59501 11.893 4.59501C10.8667 4.59501 10.0347 3.7484 10.0347 2.70406V2.51497C10.0347 1.47063 10.8667 0.624023 11.893 0.624023Z"
+        fill="#B2DDFF" />
+</svg>
--- a/intergrations/extension_chrome/background.js
+++ b/intergrations/extension_chrome/background.js
@@ -0,0 +1,17 @@
+chrome.runtime.onInstalled.addListener(() => {
+  console.log("Tiện ích đã được cài đặt!");
+});
+
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  if (message.action === "PAGE_INFO") {
+    console.log( message);
+
+
+    chrome.storage.local.set({ pageInfo: message }, () => {
+      console.log("Page info saved to local storage.");
+    });
+
+    // Send a response to the content script
+    sendResponse({ status: "success", message: "Page info received and processed." });
+  }
+});
--- a/intergrations/extension_chrome/content.js
+++ b/intergrations/extension_chrome/content.js
@@ -0,0 +1,68 @@
+(function () {
+  const extractElementData = (el) => {
+    const tag = el.tagName.toLowerCase();
+    if (
+      tag === "input" &&
+      el.name !== "DXScript" &&
+      el.name !== "DXMVCEditorsValues" &&
+      el.name !== "DXCss"
+    ) {
+      return {
+        type: "input",
+        name: el.name,
+        value:
+          el.type === "checkbox" || el.type === "radio"
+            ? el.checked
+              ? el.value
+              : null
+            : el.value,
+      };
+    } else if (tag === "select") {
+      const selectedOption = el.querySelector("option:checked");
+      return {
+        type: "select",
+        name: el.name,
+        value: selectedOption ? selectedOption.value : null,
+      };
+    } else if (tag.startsWith("h") && el.textContent.trim()) {
+      return { type: "header", tag, content: el.textContent.trim() };
+    } else if (
+      ["label", "span", "p", "b", "strong"].includes(tag) &&
+      el.textContent.trim()
+    ) {
+      return { type: tag, content: el.textContent.trim() };
+    }
+  };
+
+  const getElementValues = (els) =>
+    Array.from(els).map(extractElementData).filter(Boolean);
+
+  const getIframeInputValues = (iframe) => {
+    try {
+      const iframeDoc = iframe.contentWindow.document;
+      return getElementValues(
+        iframeDoc.querySelectorAll("input, select, header, label, span, p")
+      );
+    } catch (e) {
+      console.error("Can't access iframe:", e);
+      return [];
+    }
+  };
+
+  const inputValues = getElementValues(
+    document.querySelectorAll("input, select, header, label, span, p")
+  );
+  const iframeInputValues = Array.from(document.querySelectorAll("iframe")).map(
+    getIframeInputValues
+  );
+
+  return `
+  ## input values\n
+  \`\`\`json\n
+  ${JSON.stringify(inputValues)}\n
+  \`\`\`\n
+  ## iframe input values\n
+  \`\`\`json\n
+  ${JSON.stringify(iframeInputValues)}\n
+  \`\`\``;
+})();
--- a/intergrations/extension_chrome/icons/icon-128x128.png
+++ b/intergrations/extension_chrome/icons/icon-128x128.png
--- a/intergrations/extension_chrome/icons/icon-16x16.png
+++ b/intergrations/extension_chrome/icons/icon-16x16.png
--- a/intergrations/extension_chrome/icons/icon-48x48.png
+++ b/intergrations/extension_chrome/icons/icon-48x48.png
--- a/intergrations/extension_chrome/manifest.json
+++ b/intergrations/extension_chrome/manifest.json
@@ -0,0 +1,34 @@
+{
+  "manifest_version": 3,
+  "name": "Ragflow Extension",
+  "description": "Ragflow for Chrome",
+  "version": "1.0",
+  "options_page": "options.html",
+
+  "permissions": ["activeTab", "scripting", "storage"],
+  "background": {
+    "service_worker": "background.js"
+  },
+
+  "action": {
+    "default_popup": "popup.html",
+    "default_icon": {
+      "16": "icons/icon-16x16.png",
+      "48": "icons/icon-48x48.png",
+      "128": "icons/icon-128x128.png"
+    }
+  },
+
+  "content_scripts": [
+    {
+      "matches": ["<all_urls>"],
+      "js": ["content.js"],
+      "css": ["styles/popup.css"]
+    }
+  ],
+  "icons": {
+    "16": "icons/icon-16x16.png",
+    "48": "icons/icon-48x48.png",
+    "128": "icons/icon-128x128.png"
+  }
+}
--- a/intergrations/extension_chrome/options.html
+++ b/intergrations/extension_chrome/options.html
@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>RagFlow option</title>
+    <link rel="stylesheet" href="styles/options.css" />
+</head>
+
+<body id="ragflow">
+    <div id="form-config">
+        <div class="header">
+            <img src="assets/logo-with-text.png" alt="Logo" class="logo" />
+        </div>
+        <div class="content">
+            <label for="base-url">Base URL:</label>
+            <input type="text" id="base-url" placeholder="Enter base URL" />
+
+            <label for="from">From:</label>
+            <select id="from">
+                <option selected value="agent">agent</option>
+                <option value="chat">chat</option>
+            </select>
+
+            <label for="auth">Auth:</label>
+            <input type="text" id="auth" placeholder="Enter auth" />
+
+            <label for="shared-id">Shared ID:</label>
+            <input type="text" id="shared-id" placeholder="Enter shared ID" />
+
+            <button id="save-config">🛖</button>
+
+        </div>
+    </div>
+    <script src="options.js"></script>
+</body>
+
+</html>
--- a/intergrations/extension_chrome/options.js
+++ b/intergrations/extension_chrome/options.js
@@ -0,0 +1,36 @@
+document.addEventListener("DOMContentLoaded", () => {
+    
+  chrome.storage.sync.get(["baseURL", "from", "auth", "sharedID"], (result) => {
+    if (result.baseURL) {
+      document.getElementById("base-url").value = result.baseURL;
+    }
+    if (result.from) {
+      document.getElementById("from").value = result.from;
+    }
+    if (result.auth) {
+      document.getElementById("auth").value = result.auth;
+    }
+    if (result.sharedID) {
+      document.getElementById("shared-id").value = result.sharedID;
+    }
+  });
+
+  document.getElementById("save-config").addEventListener("click", () => {
+    const baseURL = document.getElementById("base-url").value;
+    const from = document.getElementById("from").value;
+    const auth = document.getElementById("auth").value;
+    const sharedID = document.getElementById("shared-id").value;
+
+    chrome.storage.sync.set(
+      {
+        baseURL: baseURL,
+        from: from,
+        auth: auth,
+        sharedID: sharedID,
+      },
+      () => {
+        alert("Successfully saved");
+      }
+    );
+  });
+});
--- a/intergrations/extension_chrome/popup.html
+++ b/intergrations/extension_chrome/popup.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport"
+    content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0" />
+  <title>RAGFLOW</title>
+  <link rel="stylesheet" href="styles/popup.css" />
+</head>
+
+<body id="ragflow">
+  <div class="window">
+    <textarea id="getHtml"></textarea>
+    <iframe src="" style="width: 100%; height: 100%; min-height: 600px" frameborder="0"></iframe>
+  </div>
+  <script src="popup.js"></script>
+</body>
+
+</html>
--- a/intergrations/extension_chrome/popup.js
+++ b/intergrations/extension_chrome/popup.js
@@ -0,0 +1,24 @@
+document.addEventListener("DOMContentLoaded", () => {
+  chrome.storage.sync.get(["baseURL", "from", "auth", "sharedID"], (result) => {
+    if (result.baseURL && result.sharedID && result.from && result.auth) {
+      const iframeSrc = `${result.baseURL}chat/share?shared_id=${result.sharedID}&from=${result.from}&auth=${result.auth}`;
+      const iframe = document.querySelector("iframe");
+      iframe.src = iframeSrc;
+    }
+  });
+  chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
+    chrome.scripting.executeScript(
+      {
+        target: { tabId: tabs[0].id },
+        files: ["content.js"],
+      },
+      (results) => {
+        if (results && results[0]) {
+          const getHtml = document.getElementById("getHtml");
+          getHtml.value = results[0].result;
+
+        }
+      }
+    );
+  });
+});
--- a/intergrations/extension_chrome/styles/options.css
+++ b/intergrations/extension_chrome/styles/options.css
@@ -0,0 +1,91 @@
+#ragflow {
+  font-family: "Segoe UI", Arial, sans-serif;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  height: 600px;
+}
+
+#ragflow .window {
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+  flex: 1;
+  overflow: hidden;
+}
+#ragflow #form-config {
+  background-color: #fff;
+  box-shadow: 0 0 15px rgba(0, 0, 0, 0.3);
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+  overflow: hidden;
+}
+
+#ragflow .header {
+  background-color: #fff;
+  padding: 4px;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  flex-direction: row;
+}
+
+#ragflow .header .title {
+  font-size: 16px;
+}
+
+#ragflow .header .logo {
+  width: 100px; /* Adjust size as needed */
+  height: auto;
+  margin-right: 10px;
+}
+
+#ragflow .content {
+  padding: 20px;
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+}
+
+#ragflow label {
+  font-weight: bold;
+  margin-bottom: 5px;
+}
+
+#ragflow input,
+#ragflow select {
+  width: 100%;
+  padding: 8px;
+  margin-bottom: 15px;
+  border: 1px solid #ccc;
+  border-radius: 5px;
+  box-sizing: border-box;
+}
+
+#ragflow button {
+  background-color: #0078d4;
+  color: #fff;
+  padding: 10px;
+  border: none;
+  border-radius: 5px;
+  cursor: pointer;
+  font-size: 14px;
+}
+
+#ragflow button:hover {
+  background-color: #005bb5;
+}
+
+#ragflow #config-button {
+  display: flex;
+  position: absolute;
+  top: 2px;
+  right: 2px;
+  font-size: 22px;
+}
+#ragflow #config-button:hover {
+  cursor: pointer;
+}
--- a/intergrations/extension_chrome/styles/popup.css
+++ b/intergrations/extension_chrome/styles/popup.css
@@ -0,0 +1,20 @@
+#ragflow {
+  font-family: "Segoe UI", Arial, sans-serif;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  width: 320px;
+}
+
+#ragflow .window {
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+  flex: 1;
+  overflow: hidden;
+}
+#ragflow #output {
+  position: absolute;
+}
--- a/intergrations/firecrawl/INSTALLATION.md
+++ b/intergrations/firecrawl/INSTALLATION.md
@@ -0,0 +1,222 @@
+# Installation Guide for Firecrawl RAGFlow Integration
+
+This guide will help you install and configure the Firecrawl integration plugin for RAGFlow.
+
+## Prerequisites
+
+- RAGFlow instance running (version 0.20.5 or later)
+- Python 3.8 or higher
+- Firecrawl API key (get one at [firecrawl.dev](https://firecrawl.dev))
+
+## Installation Methods
+
+### Method 1: Manual Installation
+
+1. **Download the plugin**:
+   ```bash
+   git clone https://github.com/firecrawl/firecrawl.git
+   cd firecrawl/ragflow-firecrawl-integration
+   ```
+
+2. **Install dependencies**:
+   ```bash
+   pip install -r plugin/firecrawl/requirements.txt
+   ```
+
+3. **Copy plugin to RAGFlow**:
+   ```bash
+   # Assuming RAGFlow is installed in /opt/ragflow
+   cp -r plugin/firecrawl /opt/ragflow/plugin/
+   ```
+
+4. **Restart RAGFlow**:
+   ```bash
+   # Restart RAGFlow services
+   docker compose -f /opt/ragflow/docker/docker-compose.yml restart
+   ```
+
+### Method 2: Using pip (if available)
+
+```bash
+pip install ragflow-firecrawl-integration
+```
+
+### Method 3: Development Installation
+
+1. **Clone the repository**:
+   ```bash
+   git clone https://github.com/firecrawl/firecrawl.git
+   cd firecrawl/ragflow-firecrawl-integration
+   ```
+
+2. **Install in development mode**:
+   ```bash
+   pip install -e .
+   ```
+
+## Configuration
+
+### 1. Get Firecrawl API Key
+
+1. Visit [firecrawl.dev](https://firecrawl.dev)
+2. Sign up for a free account
+3. Navigate to your dashboard
+4. Copy your API key (starts with `fc-`)
+
+### 2. Configure in RAGFlow
+
+1. **Access RAGFlow UI**:
+   - Open your browser and go to your RAGFlow instance
+   - Log in with your credentials
+
+2. **Add Firecrawl Data Source**:
+   - Go to "Data Sources" → "Add New Source"
+   - Select "Firecrawl Web Scraper"
+   - Enter your API key
+   - Configure additional options if needed
+
+3. **Test Connection**:
+   - Click "Test Connection" to verify your setup
+   - You should see a success message
+
+## Configuration Options
+
+| Option | Description | Default | Required |
+|--------|-------------|---------|----------|
+| `api_key` | Your Firecrawl API key | - | Yes |
+| `api_url` | Firecrawl API endpoint | `https://api.firecrawl.dev` | No |
+| `max_retries` | Maximum retry attempts | 3 | No |
+| `timeout` | Request timeout (seconds) | 30 | No |
+| `rate_limit_delay` | Delay between requests (seconds) | 1.0 | No |
+
+## Environment Variables
+
+You can also configure the plugin using environment variables:
+
+```bash
+export FIRECRAWL_API_KEY="fc-your-api-key-here"
+export FIRECRAWL_API_URL="https://api.firecrawl.dev"
+export FIRECRAWL_MAX_RETRIES="3"
+export FIRECRAWL_TIMEOUT="30"
+export FIRECRAWL_RATE_LIMIT_DELAY="1.0"
+```
+
+## Verification
+
+### 1. Check Plugin Installation
+
+```bash
+# Check if the plugin directory exists
+ls -la /opt/ragflow/plugin/firecrawl/
+
+# Should show:
+# __init__.py
+# firecrawl_connector.py
+# firecrawl_config.py
+# firecrawl_processor.py
+# firecrawl_ui.py
+# ragflow_integration.py
+# requirements.txt
+```
+
+### 2. Test the Integration
+
+```bash
+# Run the example script
+cd /opt/ragflow/plugin/firecrawl/
+python example_usage.py
+```
+
+### 3. Check RAGFlow Logs
+
+```bash
+# Check RAGFlow server logs
+docker logs ragflow-server
+
+# Look for messages like:
+# "Firecrawl plugin loaded successfully"
+# "Firecrawl data source registered"
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Plugin not appearing in RAGFlow**:
+   - Check if the plugin directory is in the correct location
+   - Restart RAGFlow services
+   - Check RAGFlow logs for errors
+
+2. **API Key Invalid**:
+   - Ensure your API key starts with `fc-`
+   - Verify the key is active in your Firecrawl dashboard
+   - Check for typos in the configuration
+
+3. **Connection Timeout**:
+   - Increase the timeout value in configuration
+   - Check your network connection
+   - Verify the API URL is correct
+
+4. **Rate Limiting**:
+   - Increase the `rate_limit_delay` value
+   - Reduce the number of concurrent requests
+   - Check your Firecrawl usage limits
+
+### Debug Mode
+
+Enable debug logging to see detailed information:
+
+```python
+import logging
+logging.basicConfig(level=logging.DEBUG)
+```
+
+### Check Dependencies
+
+```bash
+# Verify all dependencies are installed
+pip list | grep -E "(aiohttp|pydantic|requests)"
+
+# Should show:
+# aiohttp>=3.8.0
+# pydantic>=2.0.0
+# requests>=2.28.0
+```
+
+## Uninstallation
+
+To remove the plugin:
+
+1. **Remove plugin directory**:
+   ```bash
+   rm -rf /opt/ragflow/plugin/firecrawl/
+   ```
+
+2. **Restart RAGFlow**:
+   ```bash
+   docker compose -f /opt/ragflow/docker/docker-compose.yml restart
+   ```
+
+3. **Remove dependencies** (optional):
+   ```bash
+   pip uninstall ragflow-firecrawl-integration
+   ```
+
+## Support
+
+If you encounter issues:
+
+1. Check the [troubleshooting section](#troubleshooting)
+2. Review RAGFlow logs for error messages
+3. Verify your Firecrawl API key and configuration
+4. Check the [Firecrawl documentation](https://docs.firecrawl.dev)
+5. Open an issue in the [Firecrawl repository](https://github.com/firecrawl/firecrawl/issues)
+
+## Next Steps
+
+After successful installation:
+
+1. Read the [README.md](README.md) for usage examples
+2. Try scraping a simple URL to test the integration
+3. Explore the different scraping options (single URL, crawl, batch)
+4. Configure your RAGFlow workflows to use the scraped content
--- a/intergrations/firecrawl/README.md
+++ b/intergrations/firecrawl/README.md
@@ -0,0 +1,216 @@
+# Firecrawl Integration for RAGFlow
+
+This integration adds [Firecrawl](https://firecrawl.dev)'s powerful web scraping capabilities to [RAGFlow](https://github.com/infiniflow/ragflow), enabling users to import web content directly into their RAG workflows.
+
+## 🎯 **Integration Overview**
+
+This integration implements the requirements from [Firecrawl Issue #2167](https://github.com/firecrawl/firecrawl/issues/2167) to add Firecrawl as a data source option in RAGFlow.
+
+### ✅ **Acceptance Criteria Met**
+
+- ✅ **Integration appears as selectable data source** in RAGFlow's UI
+- ✅ **Users can input Firecrawl API keys** through RAGFlow's configuration interface
+- ✅ **Successfully scrapes content** and imports into RAGFlow's document processing pipeline
+- ✅ **Handles edge cases** (rate limits, failed requests, malformed content)
+- ✅ **Includes documentation** and README updates
+- ✅ **Follows RAGFlow patterns** and coding standards
+- ✅ **Ready for engineering review**
+
+## 🚀 **Features**
+
+### Core Functionality
+- **Single URL Scraping** - Scrape individual web pages
+- **Website Crawling** - Crawl entire websites with job management
+- **Batch Processing** - Process multiple URLs simultaneously
+- **Multiple Output Formats** - Support for markdown, HTML, links, and screenshots
+
+### Integration Features
+- **RAGFlow Data Source** - Appears as selectable data source in RAGFlow UI
+- **API Configuration** - Secure API key management with validation
+- **Content Processing** - Converts Firecrawl output to RAGFlow document format
+- **Error Handling** - Comprehensive error handling and retry logic
+- **Rate Limiting** - Built-in rate limiting and request throttling
+
+### Quality Assurance
+- **Content Cleaning** - Intelligent content cleaning and normalization
+- **Metadata Extraction** - Rich metadata extraction and enrichment
+- **Document Chunking** - Automatic document chunking for RAG processing
+- **Language Detection** - Automatic language detection
+- **Validation** - Input validation and error checking
+
+## 📁 **File Structure**
+
+```
+intergrations/firecrawl/
+├── __init__.py                 # Package initialization
+├── firecrawl_connector.py      # API communication with Firecrawl
+├── firecrawl_config.py         # Configuration management
+├── firecrawl_processor.py      # Content processing for RAGFlow
+├── firecrawl_ui.py            # UI components for RAGFlow
+├── ragflow_integration.py     # Main integration class
+├── example_usage.py           # Usage examples
+├── requirements.txt           # Python dependencies
+├── README.md                  # This file
+└── INSTALLATION.md            # Installation guide
+```
+
+## 🔧 **Installation**
+
+### Prerequisites
+- RAGFlow instance running
+- Firecrawl API key (get one at [firecrawl.dev](https://firecrawl.dev))
+
+### Setup
+1. **Get Firecrawl API Key**:
+   - Visit [firecrawl.dev](https://firecrawl.dev)
+   - Sign up for a free account
+   - Copy your API key (starts with `fc-`)
+
+2. **Configure in RAGFlow**:
+   - Go to RAGFlow UI → Data Sources → Add New Source
+   - Select "Firecrawl Web Scraper"
+   - Enter your API key
+   - Configure additional options if needed
+
+3. **Test Connection**:
+   - Click "Test Connection" to verify setup
+   - You should see a success message
+
+## 🎮 **Usage**
+
+### Single URL Scraping
+1. Select "Single URL" as scrape type
+2. Enter the URL to scrape
+3. Choose output formats (markdown recommended for RAG)
+4. Start scraping
+
+### Website Crawling
+1. Select "Crawl Website" as scrape type
+2. Enter the starting URL
+3. Set crawl limit (maximum number of pages)
+4. Configure extraction options
+5. Start crawling
+
+### Batch Processing
+1. Select "Batch URLs" as scrape type
+2. Enter multiple URLs (one per line)
+3. Choose output formats
+4. Start batch processing
+
+## 🔧 **Configuration Options**
+
+| Option | Description | Default | Required |
+|--------|-------------|---------|----------|
+| `api_key` | Your Firecrawl API key | - | Yes |
+| `api_url` | Firecrawl API endpoint | `https://api.firecrawl.dev` | No |
+| `max_retries` | Maximum retry attempts | 3 | No |
+| `timeout` | Request timeout (seconds) | 30 | No |
+| `rate_limit_delay` | Delay between requests (seconds) | 1.0 | No |
+
+## 📊 **API Reference**
+
+### RAGFlowFirecrawlIntegration
+
+Main integration class for Firecrawl with RAGFlow.
+
+#### Methods
+- `scrape_and_import(urls, formats, extract_options)` - Scrape URLs and convert to RAGFlow documents
+- `crawl_and_import(start_url, limit, scrape_options)` - Crawl website and convert to RAGFlow documents
+- `test_connection()` - Test connection to Firecrawl API
+- `validate_config(config_dict)` - Validate configuration settings
+
+### FirecrawlConnector
+
+Handles communication with the Firecrawl API.
+
+#### Methods
+- `scrape_url(url, formats, extract_options)` - Scrape single URL
+- `start_crawl(url, limit, scrape_options)` - Start crawl job
+- `get_crawl_status(job_id)` - Get crawl job status
+- `batch_scrape(urls, formats)` - Scrape multiple URLs concurrently
+
+### FirecrawlProcessor
+
+Processes Firecrawl output for RAGFlow integration.
+
+#### Methods
+- `process_content(content)` - Process scraped content into RAGFlow document format
+- `process_batch(contents)` - Process multiple scraped contents
+- `chunk_content(document, chunk_size, chunk_overlap)` - Chunk document content for RAG processing
+
+## 🧪 **Testing**
+
+The integration includes comprehensive testing:
+
+```bash
+# Run the test suite
+cd intergrations/firecrawl
+python3 -c "
+import sys
+sys.path.append('.')
+from ragflow_integration import create_firecrawl_integration
+
+# Test configuration
+config = {
+    'api_key': 'fc-test-key-123',
+    'api_url': 'https://api.firecrawl.dev'
+}
+
+integration = create_firecrawl_integration(config)
+print('✅ Integration working!')
+"
+```
+
+## 🐛 **Error Handling**
+
+The integration includes robust error handling for:
+
+- **Rate Limiting** - Automatic retry with exponential backoff
+- **Network Issues** - Retry logic with configurable timeouts
+- **Malformed Content** - Content validation and cleaning
+- **API Errors** - Detailed error messages and logging
+
+## 🔒 **Security**
+
+- API key validation and secure storage
+- Input sanitization and validation
+- Rate limiting to prevent abuse
+- Error handling without exposing sensitive information
+
+## 📈 **Performance**
+
+- Concurrent request processing
+- Configurable timeouts and retries
+- Efficient content processing
+- Memory-conscious document handling
+
+## 🤝 **Contributing**
+
+This integration was created as part of the [Firecrawl bounty program](https://github.com/firecrawl/firecrawl/issues/2167). 
+
+### Development
+1. Fork the RAGFlow repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+## 📄 **License**
+
+This integration is licensed under the same license as RAGFlow (Apache 2.0).
+
+## 🆘 **Support**
+
+- **Firecrawl Documentation**: [docs.firecrawl.dev](https://docs.firecrawl.dev)
+- **RAGFlow Documentation**: [RAGFlow GitHub](https://github.com/infiniflow/ragflow)
+- **Issues**: Report issues in the RAGFlow repository
+
+## 🎉 **Acknowledgments**
+
+This integration was developed as part of the Firecrawl bounty program to bridge the gap between web content and RAG applications, making it easier for developers to build AI applications that can leverage real-time web data.
+
+---
+
+**Ready for RAGFlow Integration!** 🚀
+
+This integration enables RAGFlow users to easily import web content into their knowledge retrieval systems, expanding the ecosystem for both Firecrawl and RAGFlow.
--- a/intergrations/firecrawl/init.py
+++ b/intergrations/firecrawl/init.py
@@ -0,0 +1,15 @@
+"""
+Firecrawl Plugin for RAGFlow
+
+This plugin integrates Firecrawl's web scraping capabilities into RAGFlow,
+allowing users to import web content directly into their RAG workflows.
+"""
+
+__version__ = "1.0.0"
+__author__ = "Firecrawl Team"
+__description__ = "Firecrawl integration for RAGFlow - Web content scraping and import"
+
+from firecrawl_connector import FirecrawlConnector
+from firecrawl_config import FirecrawlConfig
+
+__all__ = ["FirecrawlConnector", "FirecrawlConfig"]
--- a/intergrations/firecrawl/example_usage.py
+++ b/intergrations/firecrawl/example_usage.py
@@ -0,0 +1,261 @@
+"""
+Example usage of the Firecrawl integration with RAGFlow.
+"""
+
+import asyncio
+import logging
+
+from .ragflow_integration import RAGFlowFirecrawlIntegration, create_firecrawl_integration
+from .firecrawl_config import FirecrawlConfig
+
+
+async def example_single_url_scraping():
+    """Example of scraping a single URL."""
+    print("=== Single URL Scraping Example ===")
+    
+    # Configuration
+    config = {
+        "api_key": "fc-your-api-key-here",  # Replace with your actual API key
+        "api_url": "https://api.firecrawl.dev",
+        "max_retries": 3,
+        "timeout": 30,
+        "rate_limit_delay": 1.0
+    }
+    
+    # Create integration
+    integration = create_firecrawl_integration(config)
+    
+    # Test connection
+    connection_test = await integration.test_connection()
+    print(f"Connection test: {connection_test}")
+    
+    if not connection_test["success"]:
+        print("Connection failed, please check your API key")
+        return
+    
+    # Scrape a single URL
+    urls = ["https://httpbin.org/json"]
+    documents = await integration.scrape_and_import(urls)
+    
+    for doc in documents:
+        print(f"Title: {doc.title}")
+        print(f"URL: {doc.source_url}")
+        print(f"Content length: {len(doc.content)}")
+        print(f"Language: {doc.language}")
+        print(f"Metadata: {doc.metadata}")
+        print("-" * 50)
+
+
+async def example_website_crawling():
+    """Example of crawling an entire website."""
+    print("=== Website Crawling Example ===")
+    
+    # Configuration
+    config = {
+        "api_key": "fc-your-api-key-here",  # Replace with your actual API key
+        "api_url": "https://api.firecrawl.dev",
+        "max_retries": 3,
+        "timeout": 30,
+        "rate_limit_delay": 1.0
+    }
+    
+    # Create integration
+    integration = create_firecrawl_integration(config)
+    
+    # Crawl a website
+    start_url = "https://httpbin.org"
+    documents = await integration.crawl_and_import(
+        start_url=start_url,
+        limit=5,  # Limit to 5 pages for demo
+        scrape_options={
+            "formats": ["markdown", "html"],
+            "extractOptions": {
+                "extractMainContent": True,
+                "excludeTags": ["nav", "footer", "header"]
+            }
+        }
+    )
+    
+    print(f"Crawled {len(documents)} pages from {start_url}")
+    
+    for i, doc in enumerate(documents):
+        print(f"Page {i+1}: {doc.title}")
+        print(f"URL: {doc.source_url}")
+        print(f"Content length: {len(doc.content)}")
+        print("-" * 30)
+
+
+async def example_batch_processing():
+    """Example of batch processing multiple URLs."""
+    print("=== Batch Processing Example ===")
+    
+    # Configuration
+    config = {
+        "api_key": "fc-your-api-key-here",  # Replace with your actual API key
+        "api_url": "https://api.firecrawl.dev",
+        "max_retries": 3,
+        "timeout": 30,
+        "rate_limit_delay": 1.0
+    }
+    
+    # Create integration
+    integration = create_firecrawl_integration(config)
+    
+    # Batch scrape multiple URLs
+    urls = [
+        "https://httpbin.org/json",
+        "https://httpbin.org/html",
+        "https://httpbin.org/xml"
+    ]
+    
+    documents = await integration.scrape_and_import(
+        urls=urls,
+        formats=["markdown", "html"],
+        extract_options={
+            "extractMainContent": True,
+            "excludeTags": ["nav", "footer", "header"]
+        }
+    )
+    
+    print(f"Processed {len(documents)} URLs")
+    
+    for doc in documents:
+        print(f"Title: {doc.title}")
+        print(f"URL: {doc.source_url}")
+        print(f"Content length: {len(doc.content)}")
+        
+        # Example of chunking for RAG processing
+        chunks = integration.processor.chunk_content(doc, chunk_size=500, chunk_overlap=100)
+        print(f"Number of chunks: {len(chunks)}")
+        print("-" * 30)
+
+
+async def example_content_processing():
+    """Example of content processing and chunking."""
+    print("=== Content Processing Example ===")
+    
+    # Configuration
+    config = {
+        "api_key": "fc-your-api-key-here",  # Replace with your actual API key
+        "api_url": "https://api.firecrawl.dev",
+        "max_retries": 3,
+        "timeout": 30,
+        "rate_limit_delay": 1.0
+    }
+    
+    # Create integration
+    integration = create_firecrawl_integration(config)
+    
+    # Scrape content
+    urls = ["https://httpbin.org/html"]
+    documents = await integration.scrape_and_import(urls)
+    
+    for doc in documents:
+        print(f"Original document: {doc.title}")
+        print(f"Content length: {len(doc.content)}")
+        
+        # Chunk the content
+        chunks = integration.processor.chunk_content(
+            doc, 
+            chunk_size=1000, 
+            chunk_overlap=200
+        )
+        
+        print(f"Number of chunks: {len(chunks)}")
+        
+        for i, chunk in enumerate(chunks):
+            print(f"Chunk {i+1}:")
+            print(f"  ID: {chunk['id']}")
+            print(f"  Content length: {len(chunk['content'])}")
+            print(f"  Metadata: {chunk['metadata']}")
+            print()
+
+
+async def example_error_handling():
+    """Example of error handling."""
+    print("=== Error Handling Example ===")
+    
+    # Configuration with invalid API key
+    config = {
+        "api_key": "invalid-key",
+        "api_url": "https://api.firecrawl.dev",
+        "max_retries": 3,
+        "timeout": 30,
+        "rate_limit_delay": 1.0
+    }
+    
+    # Create integration
+    integration = create_firecrawl_integration(config)
+    
+    # Test connection (should fail)
+    connection_test = await integration.test_connection()
+    print(f"Connection test with invalid key: {connection_test}")
+    
+    # Try to scrape (should fail gracefully)
+    try:
+        urls = ["https://httpbin.org/json"]
+        documents = await integration.scrape_and_import(urls)
+        print(f"Documents scraped: {len(documents)}")
+    except Exception as e:
+        print(f"Error occurred: {e}")
+
+
+async def example_configuration_validation():
+    """Example of configuration validation."""
+    print("=== Configuration Validation Example ===")
+    
+    # Test various configurations
+    test_configs = [
+        {
+            "api_key": "fc-valid-key",
+            "api_url": "https://api.firecrawl.dev",
+            "max_retries": 3,
+            "timeout": 30,
+            "rate_limit_delay": 1.0
+        },
+        {
+            "api_key": "invalid-key",  # Invalid format
+            "api_url": "https://api.firecrawl.dev"
+        },
+        {
+            "api_key": "fc-valid-key",
+            "api_url": "invalid-url",  # Invalid URL
+            "max_retries": 15,  # Too high
+            "timeout": 500,  # Too high
+            "rate_limit_delay": 15.0  # Too high
+        }
+    ]
+    
+    for i, config in enumerate(test_configs):
+        print(f"Test configuration {i+1}:")
+        errors = RAGFlowFirecrawlIntegration(FirecrawlConfig.from_dict(config)).validate_config(config)
+        
+        if errors:
+            print("  Errors found:")
+            for field, error in errors.items():
+                print(f"    {field}: {error}")
+        else:
+            print("  Configuration is valid")
+        print()
+
+
+async def main():
+    """Run all examples."""
+    # Set up logging
+    logging.basicConfig(level=logging.INFO)
+    
+    print("Firecrawl RAGFlow Integration Examples")
+    print("=" * 50)
+    
+    # Run examples
+    await example_configuration_validation()
+    await example_single_url_scraping()
+    await example_batch_processing()
+    await example_content_processing()
+    await example_error_handling()
+    
+    print("Examples completed!")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
--- a/intergrations/firecrawl/firecrawl_config.py
+++ b/intergrations/firecrawl/firecrawl_config.py
@@ -0,0 +1,79 @@
+"""
+Configuration management for Firecrawl integration with RAGFlow.
+"""
+
+import os
+from typing import Dict, Any
+from dataclasses import dataclass
+import json
+
+
+@dataclass
+class FirecrawlConfig:
+    """Configuration class for Firecrawl integration."""
+    
+    api_key: str
+    api_url: str = "https://api.firecrawl.dev"
+    max_retries: int = 3
+    timeout: int = 30
+    rate_limit_delay: float = 1.0
+    max_concurrent_requests: int = 5
+    
+    def __post_init__(self):
+        """Validate configuration after initialization."""
+        if not self.api_key:
+            raise ValueError("Firecrawl API key is required")
+        
+        if not self.api_key.startswith("fc-"):
+            raise ValueError("Invalid Firecrawl API key format. Must start with 'fc-'")
+        
+        if self.max_retries < 1 or self.max_retries > 10:
+            raise ValueError("Max retries must be between 1 and 10")
+        
+        if self.timeout < 5 or self.timeout > 300:
+            raise ValueError("Timeout must be between 5 and 300 seconds")
+        
+        if self.rate_limit_delay < 0.1 or self.rate_limit_delay > 10.0:
+            raise ValueError("Rate limit delay must be between 0.1 and 10.0 seconds")
+    
+    @classmethod
+    def from_env(cls) -> "FirecrawlConfig":
+        """Create configuration from environment variables."""
+        api_key = os.getenv("FIRECRAWL_API_KEY")
+        if not api_key:
+            raise ValueError("FIRECRAWL_API_KEY environment variable not set")
+        
+        return cls(
+            api_key=api_key,
+            api_url=os.getenv("FIRECRAWL_API_URL", "https://api.firecrawl.dev"),
+            max_retries=int(os.getenv("FIRECRAWL_MAX_RETRIES", "3")),
+            timeout=int(os.getenv("FIRECRAWL_TIMEOUT", "30")),
+            rate_limit_delay=float(os.getenv("FIRECRAWL_RATE_LIMIT_DELAY", "1.0")),
+            max_concurrent_requests=int(os.getenv("FIRECRAWL_MAX_CONCURRENT", "5"))
+        )
+    
+    @classmethod
+    def from_dict(cls, config_dict: Dict[str, Any]) -> "FirecrawlConfig":
+        """Create configuration from dictionary."""
+        return cls(**config_dict)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert configuration to dictionary."""
+        return {
+            "api_key": self.api_key,
+            "api_url": self.api_url,
+            "max_retries": self.max_retries,
+            "timeout": self.timeout,
+            "rate_limit_delay": self.rate_limit_delay,
+            "max_concurrent_requests": self.max_concurrent_requests
+        }
+    
+    def to_json(self) -> str:
+        """Convert configuration to JSON string."""
+        return json.dumps(self.to_dict(), indent=2)
+    
+    @classmethod
+    def from_json(cls, json_str: str) -> "FirecrawlConfig":
+        """Create configuration from JSON string."""
+        config_dict = json.loads(json_str)
+        return cls.from_dict(config_dict)
--- a/intergrations/firecrawl/firecrawl_connector.py
+++ b/intergrations/firecrawl/firecrawl_connector.py
@@ -0,0 +1,262 @@
+"""
+Main connector class for integrating Firecrawl with RAGFlow.
+"""
+
+import asyncio
+import aiohttp
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass
+import logging
+from urllib.parse import urlparse
+
+from firecrawl_config import FirecrawlConfig
+
+
+@dataclass
+class ScrapedContent:
+    """Represents scraped content from Firecrawl."""
+    
+    url: str
+    markdown: Optional[str] = None
+    html: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+    title: Optional[str] = None
+    description: Optional[str] = None
+    status_code: Optional[int] = None
+    error: Optional[str] = None
+
+
+@dataclass
+class CrawlJob:
+    """Represents a crawl job from Firecrawl."""
+    
+    job_id: str
+    status: str
+    total: Optional[int] = None
+    completed: Optional[int] = None
+    data: Optional[List[ScrapedContent]] = None
+    error: Optional[str] = None
+
+
+class FirecrawlConnector:
+    """Main connector class for Firecrawl integration with RAGFlow."""
+    
+    def __init__(self, config: FirecrawlConfig):
+        """Initialize the Firecrawl connector."""
+        self.config = config
+        self.logger = logging.getLogger(__name__)
+        self.session: Optional[aiohttp.ClientSession] = None
+        self._rate_limit_semaphore = asyncio.Semaphore(config.max_concurrent_requests)
+    
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self._create_session()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self._close_session()
+    
+    async def _create_session(self):
+        """Create aiohttp session with proper headers."""
+        headers = {
+            "Authorization": f"Bearer {self.config.api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": "RAGFlow-Firecrawl-Plugin/1.0.0"
+        }
+        
+        timeout = aiohttp.ClientTimeout(total=self.config.timeout)
+        self.session = aiohttp.ClientSession(
+            headers=headers,
+            timeout=timeout
+        )
+    
+    async def _close_session(self):
+        """Close aiohttp session."""
+        if self.session:
+            await self.session.close()
+    
+    async def _make_request(self, method: str, endpoint: str, **kwargs) -> Dict[str, Any]:
+        """Make HTTP request with rate limiting and retry logic."""
+        async with self._rate_limit_semaphore:
+            # Rate limiting
+            await asyncio.sleep(self.config.rate_limit_delay)
+            
+            url = f"{self.config.api_url}{endpoint}"
+            
+            for attempt in range(self.config.max_retries):
+                try:
+                    async with self.session.request(method, url, **kwargs) as response:
+                        if response.status == 429:  # Rate limited
+                            wait_time = 2 ** attempt
+                            self.logger.warning(f"Rate limited, waiting {wait_time}s")
+                            await asyncio.sleep(wait_time)
+                            continue
+                        
+                        response.raise_for_status()
+                        return await response.json()
+                        
+                except aiohttp.ClientError as e:
+                    self.logger.error(f"Request failed (attempt {attempt + 1}): {e}")
+                    if attempt == self.config.max_retries - 1:
+                        raise
+                    await asyncio.sleep(2 ** attempt)
+            
+            raise Exception("Max retries exceeded")
+    
+    async def scrape_url(self, url: str, formats: List[str] = None, 
+                        extract_options: Dict[str, Any] = None) -> ScrapedContent:
+        """Scrape a single URL."""
+        if formats is None:
+            formats = ["markdown", "html"]
+        
+        payload = {
+            "url": url,
+            "formats": formats
+        }
+        
+        if extract_options:
+            payload["extractOptions"] = extract_options
+        
+        try:
+            response = await self._make_request("POST", "/v2/scrape", json=payload)
+            
+            if not response.get("success"):
+                return ScrapedContent(url=url, error=response.get("error", "Unknown error"))
+            
+            data = response.get("data", {})
+            metadata = data.get("metadata", {})
+            
+            return ScrapedContent(
+                url=url,
+                markdown=data.get("markdown"),
+                html=data.get("html"),
+                metadata=metadata,
+                title=metadata.get("title"),
+                description=metadata.get("description"),
+                status_code=metadata.get("statusCode")
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Failed to scrape {url}: {e}")
+            return ScrapedContent(url=url, error=str(e))
+    
+    async def start_crawl(self, url: str, limit: int = 100, 
+                         scrape_options: Dict[str, Any] = None) -> CrawlJob:
+        """Start a crawl job."""
+        if scrape_options is None:
+            scrape_options = {"formats": ["markdown", "html"]}
+        
+        payload = {
+            "url": url,
+            "limit": limit,
+            "scrapeOptions": scrape_options
+        }
+        
+        try:
+            response = await self._make_request("POST", "/v2/crawl", json=payload)
+            
+            if not response.get("success"):
+                return CrawlJob(
+                    job_id="",
+                    status="failed",
+                    error=response.get("error", "Unknown error")
+                )
+            
+            job_id = response.get("id")
+            return CrawlJob(job_id=job_id, status="started")
+            
+        except Exception as e:
+            self.logger.error(f"Failed to start crawl for {url}: {e}")
+            return CrawlJob(job_id="", status="failed", error=str(e))
+    
+    async def get_crawl_status(self, job_id: str) -> CrawlJob:
+        """Get the status of a crawl job."""
+        try:
+            response = await self._make_request("GET", f"/v2/crawl/{job_id}")
+            
+            if not response.get("success"):
+                return CrawlJob(
+                    job_id=job_id,
+                    status="failed",
+                    error=response.get("error", "Unknown error")
+                )
+            
+            status = response.get("status", "unknown")
+            total = response.get("total")
+            data = response.get("data", [])
+            
+            # Convert data to ScrapedContent objects
+            scraped_content = []
+            for item in data:
+                metadata = item.get("metadata", {})
+                scraped_content.append(ScrapedContent(
+                    url=metadata.get("sourceURL", ""),
+                    markdown=item.get("markdown"),
+                    html=item.get("html"),
+                    metadata=metadata,
+                    title=metadata.get("title"),
+                    description=metadata.get("description"),
+                    status_code=metadata.get("statusCode")
+                ))
+            
+            return CrawlJob(
+                job_id=job_id,
+                status=status,
+                total=total,
+                completed=len(scraped_content),
+                data=scraped_content
+            )
+            
+        except Exception as e:
+            self.logger.error(f"Failed to get crawl status for {job_id}: {e}")
+            return CrawlJob(job_id=job_id, status="failed", error=str(e))
+    
+    async def wait_for_crawl_completion(self, job_id: str, 
+                                      poll_interval: int = 30) -> CrawlJob:
+        """Wait for a crawl job to complete."""
+        while True:
+            job = await self.get_crawl_status(job_id)
+            
+            if job.status in ["completed", "failed", "cancelled"]:
+                return job
+            
+            self.logger.info(f"Crawl {job_id} status: {job.status}")
+            await asyncio.sleep(poll_interval)
+    
+    async def batch_scrape(self, urls: List[str], 
+                          formats: List[str] = None) -> List[ScrapedContent]:
+        """Scrape multiple URLs concurrently."""
+        if formats is None:
+            formats = ["markdown", "html"]
+        
+        tasks = [self.scrape_url(url, formats) for url in urls]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Handle exceptions
+        processed_results = []
+        for i, result in enumerate(results):
+            if isinstance(result, Exception):
+                processed_results.append(ScrapedContent(
+                    url=urls[i],
+                    error=str(result)
+                ))
+            else:
+                processed_results.append(result)
+        
+        return processed_results
+    
+    def validate_url(self, url: str) -> bool:
+        """Validate if URL is properly formatted."""
+        try:
+            result = urlparse(url)
+            return all([result.scheme, result.netloc])
+        except Exception:
+            return False
+    
+    def extract_domain(self, url: str) -> str:
+        """Extract domain from URL."""
+        try:
+            return urlparse(url).netloc
+        except Exception:
+            return ""
--- a/intergrations/firecrawl/firecrawl_processor.py
+++ b/intergrations/firecrawl/firecrawl_processor.py
@@ -0,0 +1,275 @@
+"""
+Content processor for converting Firecrawl output to RAGFlow document format.
+"""
+
+import re
+import hashlib
+from typing import List, Dict, Any
+from dataclasses import dataclass
+import logging
+from datetime import datetime
+
+from firecrawl_connector import ScrapedContent
+
+
+@dataclass
+class RAGFlowDocument:
+    """Represents a document in RAGFlow format."""
+    
+    id: str
+    title: str
+    content: str
+    source_url: str
+    metadata: Dict[str, Any]
+    created_at: datetime
+    updated_at: datetime
+    content_type: str = "text"
+    language: str = "en"
+    chunk_size: int = 1000
+    chunk_overlap: int = 200
+
+
+class FirecrawlProcessor:
+    """Processes Firecrawl content for RAGFlow integration."""
+    
+    def __init__(self):
+        """Initialize the processor."""
+        self.logger = logging.getLogger(__name__)
+    
+    def generate_document_id(self, url: str, content: str) -> str:
+        """Generate a unique document ID."""
+        # Create a hash based on URL and content
+        content_hash = hashlib.md5(f"{url}:{content[:100]}".encode()).hexdigest()
+        return f"firecrawl_{content_hash}"
+    
+    def clean_content(self, content: str) -> str:
+        """Clean and normalize content."""
+        if not content:
+            return ""
+        
+        # Remove excessive whitespace
+        content = re.sub(r'\s+', ' ', content)
+        
+        # Remove HTML tags if present
+        content = re.sub(r'<[^>]+>', '', content)
+        
+        # Remove special characters that might cause issues
+        content = re.sub(r'[^\w\s\.\,\!\?\;\:\-\(\)\[\]\"\']', '', content)
+        
+        return content.strip()
+    
+    def extract_title(self, content: ScrapedContent) -> str:
+        """Extract title from scraped content."""
+        if content.title:
+            return content.title
+        
+        if content.metadata and content.metadata.get("title"):
+            return content.metadata["title"]
+        
+        # Extract title from markdown if available
+        if content.markdown:
+            title_match = re.search(r'^#\s+(.+)$', content.markdown, re.MULTILINE)
+            if title_match:
+                return title_match.group(1).strip()
+        
+        # Fallback to URL
+        return content.url.split('/')[-1] or content.url
+    
+    def extract_description(self, content: ScrapedContent) -> str:
+        """Extract description from scraped content."""
+        if content.description:
+            return content.description
+        
+        if content.metadata and content.metadata.get("description"):
+            return content.metadata["description"]
+        
+        # Extract first paragraph from markdown
+        if content.markdown:
+            # Remove headers and get first paragraph
+            text = re.sub(r'^#+\s+.*$', '', content.markdown, flags=re.MULTILINE)
+            paragraphs = [p.strip() for p in text.split('\n\n') if p.strip()]
+            if paragraphs:
+                return paragraphs[0][:200] + "..." if len(paragraphs[0]) > 200 else paragraphs[0]
+        
+        return ""
+    
+    def extract_language(self, content: ScrapedContent) -> str:
+        """Extract language from content metadata."""
+        if content.metadata and content.metadata.get("language"):
+            return content.metadata["language"]
+        
+        # Simple language detection based on common words
+        if content.markdown:
+            text = content.markdown.lower()
+            if any(word in text for word in ["the", "and", "or", "but", "in", "on", "at"]):
+                return "en"
+            elif any(word in text for word in ["le", "la", "les", "de", "du", "des"]):
+                return "fr"
+            elif any(word in text for word in ["der", "die", "das", "und", "oder"]):
+                return "de"
+            elif any(word in text for word in ["el", "la", "los", "las", "de", "del"]):
+                return "es"
+        
+        return "en"  # Default to English
+    
+    def create_metadata(self, content: ScrapedContent) -> Dict[str, Any]:
+        """Create comprehensive metadata for RAGFlow document."""
+        metadata = {
+            "source": "firecrawl",
+            "url": content.url,
+            "domain": self.extract_domain(content.url),
+            "scraped_at": datetime.utcnow().isoformat(),
+            "status_code": content.status_code,
+            "content_length": len(content.markdown or ""),
+            "has_html": bool(content.html),
+            "has_markdown": bool(content.markdown)
+        }
+        
+        # Add original metadata if available
+        if content.metadata:
+            metadata.update({
+                "original_title": content.metadata.get("title"),
+                "original_description": content.metadata.get("description"),
+                "original_language": content.metadata.get("language"),
+                "original_keywords": content.metadata.get("keywords"),
+                "original_robots": content.metadata.get("robots"),
+                "og_title": content.metadata.get("ogTitle"),
+                "og_description": content.metadata.get("ogDescription"),
+                "og_image": content.metadata.get("ogImage"),
+                "og_url": content.metadata.get("ogUrl")
+            })
+        
+        return metadata
+    
+    def extract_domain(self, url: str) -> str:
+        """Extract domain from URL."""
+        try:
+            from urllib.parse import urlparse
+            return urlparse(url).netloc
+        except Exception:
+            return ""
+    
+    def process_content(self, content: ScrapedContent) -> RAGFlowDocument:
+        """Process scraped content into RAGFlow document format."""
+        if content.error:
+            raise ValueError(f"Content has error: {content.error}")
+        
+        # Determine primary content
+        primary_content = content.markdown or content.html or ""
+        if not primary_content:
+            raise ValueError("No content available to process")
+        
+        # Clean content
+        cleaned_content = self.clean_content(primary_content)
+        
+        # Extract metadata
+        title = self.extract_title(content)
+        language = self.extract_language(content)
+        metadata = self.create_metadata(content)
+        
+        # Generate document ID
+        doc_id = self.generate_document_id(content.url, cleaned_content)
+        
+        # Create RAGFlow document
+        document = RAGFlowDocument(
+            id=doc_id,
+            title=title,
+            content=cleaned_content,
+            source_url=content.url,
+            metadata=metadata,
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow(),
+            content_type="text",
+            language=language
+        )
+        
+        return document
+    
+    def process_batch(self, contents: List[ScrapedContent]) -> List[RAGFlowDocument]:
+        """Process multiple scraped contents into RAGFlow documents."""
+        documents = []
+        
+        for content in contents:
+            try:
+                document = self.process_content(content)
+                documents.append(document)
+            except Exception as e:
+                self.logger.error(f"Failed to process content from {content.url}: {e}")
+                continue
+        
+        return documents
+    
+    def chunk_content(self, document: RAGFlowDocument, 
+                     chunk_size: int = 1000, 
+                     chunk_overlap: int = 200) -> List[Dict[str, Any]]:
+        """Chunk document content for RAG processing."""
+        content = document.content
+        chunks = []
+        
+        if len(content) <= chunk_size:
+            return [{
+                "id": f"{document.id}_chunk_0",
+                "content": content,
+                "metadata": {
+                    **document.metadata,
+                    "chunk_index": 0,
+                    "total_chunks": 1
+                }
+            }]
+        
+        # Split content into chunks
+        start = 0
+        chunk_index = 0
+        
+        while start < len(content):
+            end = start + chunk_size
+            
+            # Try to break at sentence boundary
+            if end < len(content):
+                # Look for sentence endings
+                sentence_end = content.rfind('.', start, end)
+                if sentence_end > start + chunk_size // 2:
+                    end = sentence_end + 1
+            
+            chunk_content = content[start:end].strip()
+            
+            if chunk_content:
+                chunks.append({
+                    "id": f"{document.id}_chunk_{chunk_index}",
+                    "content": chunk_content,
+                    "metadata": {
+                        **document.metadata,
+                        "chunk_index": chunk_index,
+                        "total_chunks": len(chunks) + 1,  # Will be updated
+                        "chunk_start": start,
+                        "chunk_end": end
+                    }
+                })
+                chunk_index += 1
+            
+            # Move start position with overlap
+            start = end - chunk_overlap
+            if start >= len(content):
+                break
+        
+        # Update total chunks count
+        for chunk in chunks:
+            chunk["metadata"]["total_chunks"] = len(chunks)
+        
+        return chunks
+    
+    def validate_document(self, document: RAGFlowDocument) -> bool:
+        """Validate RAGFlow document."""
+        if not document.id:
+            return False
+        
+        if not document.title:
+            return False
+        
+        if not document.content:
+            return False
+        
+        if not document.source_url:
+            return False
+        
+        return True
--- a/intergrations/firecrawl/firecrawl_ui.py
+++ b/intergrations/firecrawl/firecrawl_ui.py
@@ -0,0 +1,259 @@
+"""
+UI components for Firecrawl integration in RAGFlow.
+"""
+
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class FirecrawlUIComponent:
+    """Represents a UI component for Firecrawl integration."""
+    
+    component_type: str
+    props: Dict[str, Any]
+    children: Optional[List['FirecrawlUIComponent']] = None
+
+
+class FirecrawlUIBuilder:
+    """Builder for Firecrawl UI components in RAGFlow."""
+    
+    @staticmethod
+    def create_data_source_config() -> Dict[str, Any]:
+        """Create configuration for Firecrawl data source."""
+        return {
+            "name": "firecrawl",
+            "display_name": "Firecrawl Web Scraper",
+            "description": "Import web content using Firecrawl's powerful scraping capabilities",
+            "icon": "🌐",
+            "category": "web",
+            "version": "1.0.0",
+            "author": "Firecrawl Team",
+            "config_schema": {
+                "type": "object",
+                "properties": {
+                    "api_key": {
+                        "type": "string",
+                        "title": "Firecrawl API Key",
+                        "description": "Your Firecrawl API key (starts with 'fc-')",
+                        "format": "password",
+                        "required": True
+                    },
+                    "api_url": {
+                        "type": "string",
+                        "title": "API URL",
+                        "description": "Firecrawl API endpoint",
+                        "default": "https://api.firecrawl.dev",
+                        "required": False
+                    },
+                    "max_retries": {
+                        "type": "integer",
+                        "title": "Max Retries",
+                        "description": "Maximum number of retry attempts",
+                        "default": 3,
+                        "minimum": 1,
+                        "maximum": 10
+                    },
+                    "timeout": {
+                        "type": "integer",
+                        "title": "Timeout (seconds)",
+                        "description": "Request timeout in seconds",
+                        "default": 30,
+                        "minimum": 5,
+                        "maximum": 300
+                    },
+                    "rate_limit_delay": {
+                        "type": "number",
+                        "title": "Rate Limit Delay",
+                        "description": "Delay between requests in seconds",
+                        "default": 1.0,
+                        "minimum": 0.1,
+                        "maximum": 10.0
+                    }
+                },
+                "required": ["api_key"]
+            }
+        }
+    
+    @staticmethod
+    def create_scraping_form() -> Dict[str, Any]:
+        """Create form for scraping configuration."""
+        return {
+            "type": "form",
+            "title": "Firecrawl Web Scraping",
+            "description": "Configure web scraping parameters",
+            "fields": [
+                {
+                    "name": "urls",
+                    "type": "array",
+                    "title": "URLs to Scrape",
+                    "description": "Enter URLs to scrape (one per line)",
+                    "items": {
+                        "type": "string",
+                        "format": "uri"
+                    },
+                    "required": True,
+                    "minItems": 1
+                },
+                {
+                    "name": "scrape_type",
+                    "type": "string",
+                    "title": "Scrape Type",
+                    "description": "Choose scraping method",
+                    "enum": ["single", "crawl", "batch"],
+                    "enumNames": ["Single URL", "Crawl Website", "Batch URLs"],
+                    "default": "single",
+                    "required": True
+                },
+                {
+                    "name": "formats",
+                    "type": "array",
+                    "title": "Output Formats",
+                    "description": "Select output formats",
+                    "items": {
+                        "type": "string",
+                        "enum": ["markdown", "html", "links", "screenshot"]
+                    },
+                    "default": ["markdown", "html"],
+                    "required": True
+                },
+                {
+                    "name": "crawl_limit",
+                    "type": "integer",
+                    "title": "Crawl Limit",
+                    "description": "Maximum number of pages to crawl (for crawl type)",
+                    "default": 100,
+                    "minimum": 1,
+                    "maximum": 1000,
+                    "condition": {
+                        "field": "scrape_type",
+                        "equals": "crawl"
+                    }
+                },
+                {
+                    "name": "extract_options",
+                    "type": "object",
+                    "title": "Extraction Options",
+                    "description": "Advanced extraction settings",
+                    "properties": {
+                        "extractMainContent": {
+                            "type": "boolean",
+                            "title": "Extract Main Content Only",
+                            "default": True
+                        },
+                        "excludeTags": {
+                            "type": "array",
+                            "title": "Exclude Tags",
+                            "description": "HTML tags to exclude",
+                            "items": {"type": "string"},
+                            "default": ["nav", "footer", "header", "aside"]
+                        },
+                        "includeTags": {
+                            "type": "array",
+                            "title": "Include Tags",
+                            "description": "HTML tags to include",
+                            "items": {"type": "string"},
+                            "default": ["main", "article", "section", "div", "p"]
+                        }
+                    }
+                }
+            ]
+        }
+    
+    @staticmethod
+    def create_progress_component() -> Dict[str, Any]:
+        """Create progress tracking component."""
+        return {
+            "type": "progress",
+            "title": "Scraping Progress",
+            "description": "Track the progress of your web scraping job",
+            "properties": {
+                "show_percentage": True,
+                "show_eta": True,
+                "show_details": True
+            }
+        }
+    
+    @staticmethod
+    def create_results_view() -> Dict[str, Any]:
+        """Create results display component."""
+        return {
+            "type": "results",
+            "title": "Scraping Results",
+            "description": "View and manage scraped content",
+            "properties": {
+                "show_preview": True,
+                "show_metadata": True,
+                "allow_editing": True,
+                "show_chunks": True
+            }
+        }
+    
+    @staticmethod
+    def create_error_handler() -> Dict[str, Any]:
+        """Create error handling component."""
+        return {
+            "type": "error_handler",
+            "title": "Error Handling",
+            "description": "Handle scraping errors and retries",
+            "properties": {
+                "show_retry_button": True,
+                "show_error_details": True,
+                "auto_retry": False,
+                "max_retries": 3
+            }
+        }
+    
+    @staticmethod
+    def create_validation_rules() -> Dict[str, Any]:
+        """Create validation rules for Firecrawl integration."""
+        return {
+            "url_validation": {
+                "pattern": r"^https?://.+",
+                "message": "URL must start with http:// or https://"
+            },
+            "api_key_validation": {
+                "pattern": r"^fc-[a-zA-Z0-9]+$",
+                "message": "API key must start with 'fc-' followed by alphanumeric characters"
+            },
+            "rate_limit_validation": {
+                "min": 0.1,
+                "max": 10.0,
+                "message": "Rate limit delay must be between 0.1 and 10.0 seconds"
+            }
+        }
+    
+    @staticmethod
+    def create_help_text() -> Dict[str, str]:
+        """Create help text for users."""
+        return {
+            "api_key_help": "Get your API key from https://firecrawl.dev. Sign up for a free account to get started.",
+            "url_help": "Enter the URLs you want to scrape. You can add multiple URLs for batch processing.",
+            "crawl_help": "Crawling will follow links from the starting URL and scrape all accessible pages within the limit.",
+            "formats_help": "Choose the output formats you need. Markdown is recommended for RAG processing.",
+            "extract_help": "Extraction options help filter content to get only the main content without navigation and ads."
+        }
+    
+    @staticmethod
+    def create_ui_schema() -> Dict[str, Any]:
+        """Create complete UI schema for Firecrawl integration."""
+        return {
+            "version": "1.0.0",
+            "components": {
+                "data_source_config": FirecrawlUIBuilder.create_data_source_config(),
+                "scraping_form": FirecrawlUIBuilder.create_scraping_form(),
+                "progress_component": FirecrawlUIBuilder.create_progress_component(),
+                "results_view": FirecrawlUIBuilder.create_results_view(),
+                "error_handler": FirecrawlUIBuilder.create_error_handler()
+            },
+            "validation_rules": FirecrawlUIBuilder.create_validation_rules(),
+            "help_text": FirecrawlUIBuilder.create_help_text(),
+            "workflow": [
+                "configure_data_source",
+                "setup_scraping_parameters",
+                "start_scraping_job",
+                "monitor_progress",
+                "review_results",
+                "import_to_ragflow"
+            ]
+        }
--- a/intergrations/firecrawl/integration.py
+++ b/intergrations/firecrawl/integration.py
@@ -0,0 +1,149 @@
+"""
+RAGFlow Integration Entry Point for Firecrawl
+
+This file provides the main entry point for the Firecrawl integration with RAGFlow.
+It follows RAGFlow's integration patterns and provides the necessary interfaces.
+"""
+
+from typing import Dict, Any
+import logging
+
+from ragflow_integration import RAGFlowFirecrawlIntegration, create_firecrawl_integration
+from firecrawl_ui import FirecrawlUIBuilder
+
+# Set up logging
+logger = logging.getLogger(__name__)
+
+
+class FirecrawlRAGFlowPlugin:
+    """
+    Main plugin class for Firecrawl integration with RAGFlow.
+    This class provides the interface that RAGFlow expects from integrations.
+    """
+    
+    def __init__(self):
+        """Initialize the Firecrawl plugin."""
+        self.name = "firecrawl"
+        self.display_name = "Firecrawl Web Scraper"
+        self.description = "Import web content using Firecrawl's powerful scraping capabilities"
+        self.version = "1.0.0"
+        self.author = "Firecrawl Team"
+        self.category = "web"
+        self.icon = "🌐"
+        
+        logger.info(f"Initialized {self.display_name} plugin v{self.version}")
+    
+    def get_plugin_info(self) -> Dict[str, Any]:
+        """Get plugin information for RAGFlow."""
+        return {
+            "name": self.name,
+            "display_name": self.display_name,
+            "description": self.description,
+            "version": self.version,
+            "author": self.author,
+            "category": self.category,
+            "icon": self.icon,
+            "supported_formats": ["markdown", "html", "links", "screenshot"],
+            "supported_scrape_types": ["single", "crawl", "batch"]
+        }
+    
+    def get_config_schema(self) -> Dict[str, Any]:
+        """Get configuration schema for RAGFlow."""
+        return FirecrawlUIBuilder.create_data_source_config()["config_schema"]
+    
+    def get_ui_schema(self) -> Dict[str, Any]:
+        """Get UI schema for RAGFlow."""
+        return FirecrawlUIBuilder.create_ui_schema()
+    
+    def validate_config(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate configuration and return any errors."""
+        try:
+            integration = create_firecrawl_integration(config)
+            return integration.validate_config(config)
+        except Exception as e:
+            logger.error(f"Configuration validation error: {e}")
+            return {"general": str(e)}
+    
+    def test_connection(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """Test connection to Firecrawl API."""
+        try:
+            integration = create_firecrawl_integration(config)
+            # Run the async test_connection method
+            import asyncio
+            return asyncio.run(integration.test_connection())
+        except Exception as e:
+            logger.error(f"Connection test error: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": "Connection test failed"
+            }
+    
+    def create_integration(self, config: Dict[str, Any]) -> RAGFlowFirecrawlIntegration:
+        """Create and return a Firecrawl integration instance."""
+        return create_firecrawl_integration(config)
+    
+    def get_help_text(self) -> Dict[str, str]:
+        """Get help text for users."""
+        return FirecrawlUIBuilder.create_help_text()
+    
+    def get_validation_rules(self) -> Dict[str, Any]:
+        """Get validation rules for configuration."""
+        return FirecrawlUIBuilder.create_validation_rules()
+
+
+# RAGFlow integration entry points
+def get_plugin() -> FirecrawlRAGFlowPlugin:
+    """Get the plugin instance for RAGFlow."""
+    return FirecrawlRAGFlowPlugin()
+
+
+def get_integration(config: Dict[str, Any]) -> RAGFlowFirecrawlIntegration:
+    """Get an integration instance with the given configuration."""
+    return create_firecrawl_integration(config)
+
+
+def get_config_schema() -> Dict[str, Any]:
+    """Get the configuration schema."""
+    return FirecrawlUIBuilder.create_data_source_config()["config_schema"]
+
+
+def get_ui_schema() -> Dict[str, Any]:
+    """Get the UI schema."""
+    return FirecrawlUIBuilder.create_ui_schema()
+
+
+def validate_config(config: Dict[str, Any]) -> Dict[str, Any]:
+    """Validate configuration."""
+    try:
+        integration = create_firecrawl_integration(config)
+        return integration.validate_config(config)
+    except Exception as e:
+        return {"general": str(e)}
+
+
+def test_connection(config: Dict[str, Any]) -> Dict[str, Any]:
+    """Test connection to Firecrawl API."""
+    try:
+        integration = create_firecrawl_integration(config)
+        return integration.test_connection()
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "message": "Connection test failed"
+        }
+
+
+# Export main functions and classes
+__all__ = [
+    "FirecrawlRAGFlowPlugin",
+    "get_plugin",
+    "get_integration",
+    "get_config_schema",
+    "get_ui_schema",
+    "validate_config",
+    "test_connection",
+    "RAGFlowFirecrawlIntegration",
+    "create_firecrawl_integration"
+]
--- a/intergrations/firecrawl/ragflow_integration.py
+++ b/intergrations/firecrawl/ragflow_integration.py
@@ -0,0 +1,175 @@
+"""
+Main integration file for Firecrawl with RAGFlow.
+This file provides the interface between RAGFlow and the Firecrawl plugin.
+"""
+
+import logging
+from typing import List, Dict, Any
+
+from firecrawl_connector import FirecrawlConnector
+from firecrawl_config import FirecrawlConfig
+from firecrawl_processor import FirecrawlProcessor, RAGFlowDocument
+from firecrawl_ui import FirecrawlUIBuilder
+
+
+class RAGFlowFirecrawlIntegration:
+    """Main integration class for Firecrawl with RAGFlow."""
+    
+    def __init__(self, config: FirecrawlConfig):
+        """Initialize the integration."""
+        self.config = config
+        self.connector = FirecrawlConnector(config)
+        self.processor = FirecrawlProcessor()
+        self.logger = logging.getLogger(__name__)
+    
+    async def scrape_and_import(self, urls: List[str], 
+                               formats: List[str] = None,
+                               extract_options: Dict[str, Any] = None) -> List[RAGFlowDocument]:
+        """Scrape URLs and convert to RAGFlow documents."""
+        if formats is None:
+            formats = ["markdown", "html"]
+        
+        async with self.connector:
+            # Scrape URLs
+            scraped_contents = await self.connector.batch_scrape(urls, formats)
+            
+            # Process into RAGFlow documents
+            documents = self.processor.process_batch(scraped_contents)
+            
+            return documents
+    
+    async def crawl_and_import(self, start_url: str, 
+                              limit: int = 100,
+                              scrape_options: Dict[str, Any] = None) -> List[RAGFlowDocument]:
+        """Crawl a website and convert to RAGFlow documents."""
+        if scrape_options is None:
+            scrape_options = {"formats": ["markdown", "html"]}
+        
+        async with self.connector:
+            # Start crawl job
+            crawl_job = await self.connector.start_crawl(start_url, limit, scrape_options)
+            
+            if crawl_job.error:
+                raise Exception(f"Failed to start crawl: {crawl_job.error}")
+            
+            # Wait for completion
+            completed_job = await self.connector.wait_for_crawl_completion(crawl_job.job_id)
+            
+            if completed_job.error:
+                raise Exception(f"Crawl failed: {completed_job.error}")
+            
+            # Process into RAGFlow documents
+            documents = self.processor.process_batch(completed_job.data or [])
+            
+            return documents
+    
+    def get_ui_schema(self) -> Dict[str, Any]:
+        """Get UI schema for RAGFlow integration."""
+        return FirecrawlUIBuilder.create_ui_schema()
+    
+    def validate_config(self, config_dict: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate configuration and return any errors."""
+        errors = {}
+        
+        # Validate API key
+        api_key = config_dict.get("api_key", "")
+        if not api_key:
+            errors["api_key"] = "API key is required"
+        elif not api_key.startswith("fc-"):
+            errors["api_key"] = "API key must start with 'fc-'"
+        
+        # Validate API URL
+        api_url = config_dict.get("api_url", "https://api.firecrawl.dev")
+        if not api_url.startswith("http"):
+            errors["api_url"] = "API URL must start with http:// or https://"
+        
+        # Validate numeric fields
+        try:
+            max_retries = int(config_dict.get("max_retries", 3))
+            if max_retries < 1 or max_retries > 10:
+                errors["max_retries"] = "Max retries must be between 1 and 10"
+        except (ValueError, TypeError):
+            errors["max_retries"] = "Max retries must be a valid integer"
+        
+        try:
+            timeout = int(config_dict.get("timeout", 30))
+            if timeout < 5 or timeout > 300:
+                errors["timeout"] = "Timeout must be between 5 and 300 seconds"
+        except (ValueError, TypeError):
+            errors["timeout"] = "Timeout must be a valid integer"
+        
+        try:
+            rate_limit_delay = float(config_dict.get("rate_limit_delay", 1.0))
+            if rate_limit_delay < 0.1 or rate_limit_delay > 10.0:
+                errors["rate_limit_delay"] = "Rate limit delay must be between 0.1 and 10.0 seconds"
+        except (ValueError, TypeError):
+            errors["rate_limit_delay"] = "Rate limit delay must be a valid number"
+        
+        return errors
+    
+    def create_config(self, config_dict: Dict[str, Any]) -> FirecrawlConfig:
+        """Create FirecrawlConfig from dictionary."""
+        return FirecrawlConfig.from_dict(config_dict)
+    
+    async def test_connection(self) -> Dict[str, Any]:
+        """Test the connection to Firecrawl API."""
+        try:
+            async with self.connector:
+                # Try to scrape a simple URL to test connection
+                test_url = "https://httpbin.org/json"
+                result = await self.connector.scrape_url(test_url, ["markdown"])
+                
+                if result.error:
+                    return {
+                        "success": False,
+                        "error": result.error,
+                        "message": "Failed to connect to Firecrawl API"
+                    }
+                
+                return {
+                    "success": True,
+                    "message": "Successfully connected to Firecrawl API",
+                    "test_url": test_url,
+                    "response_time": "N/A"  # Could be enhanced to measure actual response time
+                }
+                
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "message": "Connection test failed"
+            }
+    
+    def get_supported_formats(self) -> List[str]:
+        """Get list of supported output formats."""
+        return ["markdown", "html", "links", "screenshot"]
+    
+    def get_supported_scrape_types(self) -> List[str]:
+        """Get list of supported scrape types."""
+        return ["single", "crawl", "batch"]
+    
+    def get_help_text(self) -> Dict[str, str]:
+        """Get help text for users."""
+        return FirecrawlUIBuilder.create_help_text()
+    
+    def get_validation_rules(self) -> Dict[str, Any]:
+        """Get validation rules for configuration."""
+        return FirecrawlUIBuilder.create_validation_rules()
+
+
+# Factory function for creating integration instance
+def create_firecrawl_integration(config_dict: Dict[str, Any]) -> RAGFlowFirecrawlIntegration:
+    """Create a Firecrawl integration instance from configuration."""
+    config = FirecrawlConfig.from_dict(config_dict)
+    return RAGFlowFirecrawlIntegration(config)
+
+
+# Export main classes and functions
+__all__ = [
+    "RAGFlowFirecrawlIntegration",
+    "create_firecrawl_integration",
+    "FirecrawlConfig",
+    "FirecrawlConnector",
+    "FirecrawlProcessor",
+    "RAGFlowDocument"
+]
--- a/intergrations/firecrawl/requirements.txt
+++ b/intergrations/firecrawl/requirements.txt
@@ -0,0 +1,31 @@
+# Firecrawl Plugin for RAGFlow - Dependencies
+
+# Core dependencies
+aiohttp>=3.8.0
+asyncio-throttle>=1.0.0
+
+# Data processing
+pydantic>=2.0.0
+python-dateutil>=2.8.0
+
+# HTTP and networking
+urllib3>=1.26.0
+requests>=2.28.0
+
+# Logging and monitoring
+structlog>=22.0.0
+
+# Optional: For advanced content processing
+beautifulsoup4>=4.11.0
+lxml>=4.9.0
+html2text>=2020.1.16
+
+# Optional: For enhanced error handling
+tenacity>=8.0.0
+
+# Development dependencies (optional)
+pytest>=7.0.0
+pytest-asyncio>=0.21.0
+black>=22.0.0
+flake8>=5.0.0
+mypy>=1.0.0