Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,6 @@
+.dockerignore
+node_modules
+README.md
+.next
+.git
+out

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,146 @@
+name: Bug report
+description: Create a report to help us improve
+title: "[Bug]: "
+labels: ["bug"]
+
+body:
+  - type: markdown
+    attributes:
+      value: "## Describe the bug"
+  - type: textarea
+    id: bug-description
+    attributes:
+      label: "Bug Description"
+      description: "A clear and concise description of what the bug is."
+      placeholder: "Explain the bug..."
+    validations:
+      required: true
+
+  - type: markdown
+    attributes:
+      value: "## To Reproduce"
+  - type: textarea
+    id: steps-to-reproduce
+    attributes:
+      label: "Steps to Reproduce"
+      description: "Steps to reproduce the behavior:"
+      placeholder: |
+        1. Go to '...'
+        2. Click on '....'
+        3. Scroll down to '....'
+        4. See error
+    validations:
+      required: true
+
+  - type: markdown
+    attributes:
+      value: "## Expected behavior"
+  - type: textarea
+    id: expected-behavior
+    attributes:
+      label: "Expected Behavior"
+      description: "A clear and concise description of what you expected to happen."
+      placeholder: "Describe what you expected to happen..."
+    validations:
+      required: true
+
+  - type: markdown
+    attributes:
+      value: "## Screenshots"
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: "Screenshots"
+      description: "If applicable, add screenshots to help explain your problem."
+      placeholder: "Paste your screenshots here or write 'N/A' if not applicable..."
+    validations:
+      required: false
+
+  - type: markdown
+    attributes:
+      value: "## Deployment"
+  - type: checkboxes
+    id: deployment
+    attributes:
+      label: "Deployment Method"
+      description: "Please select the deployment method you are using."
+      options:
+        - label: "Docker"
+        - label: "Vercel"
+        - label: "Server"
+
+  - type: markdown
+    attributes:
+      value: "## Desktop (please complete the following information):"
+  - type: input
+    id: desktop-os
+    attributes:
+      label: "Desktop OS"
+      description: "Your desktop operating system."
+      placeholder: "e.g., Windows 10"
+    validations:
+      required: false
+  - type: input
+    id: desktop-browser
+    attributes:
+      label: "Desktop Browser"
+      description: "Your desktop browser."
+      placeholder: "e.g., Chrome, Safari"
+    validations:
+      required: false
+  - type: input
+    id: desktop-version
+    attributes:
+      label: "Desktop Browser Version"
+      description: "Version of your desktop browser."
+      placeholder: "e.g., 89.0"
+    validations:
+      required: false
+
+  - type: markdown
+    attributes:
+      value: "## Smartphone (please complete the following information):"
+  - type: input
+    id: smartphone-device
+    attributes:
+      label: "Smartphone Device"
+      description: "Your smartphone device."
+      placeholder: "e.g., iPhone X"
+    validations:
+      required: false
+  - type: input
+    id: smartphone-os
+    attributes:
+      label: "Smartphone OS"
+      description: "Your smartphone operating system."
+      placeholder: "e.g., iOS 14.4"
+    validations:
+      required: false
+  - type: input
+    id: smartphone-browser
+    attributes:
+      label: "Smartphone Browser"
+      description: "Your smartphone browser."
+      placeholder: "e.g., Safari"
+    validations:
+      required: false
+  - type: input
+    id: smartphone-version
+    attributes:
+      label: "Smartphone Browser Version"
+      description: "Version of your smartphone browser."
+      placeholder: "e.g., 14"
+    validations:
+      required: false
+
+  - type: markdown
+    attributes:
+      value: "## Additional Logs"
+  - type: textarea
+    id: additional-logs
+    attributes:
+      label: "Additional Logs"
+      description: "Add any logs about the problem here."
+      placeholder: "Paste any relevant logs here..."
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,53 @@
+name: Feature request
+description: Suggest an idea for this project
+title: "[Feature Request]: "
+labels: ["feature"]
+
+body:
+  - type: markdown
+    attributes:
+      value: "## Is your feature request related to a problem? Please describe."
+  - type: textarea
+    id: problem-description
+    attributes:
+      label: Problem Description
+      description: "A clear and concise description of what the problem is. Example: I'm always frustrated when [...]"
+      placeholder: "Explain the problem you are facing..."
+    validations:
+      required: true
+
+  - type: markdown
+    attributes:
+      value: "## Describe the solution you'd like"
+  - type: textarea
+    id: desired-solution
+    attributes:
+      label: Solution Description
+      description: A clear and concise description of what you want to happen.
+      placeholder: "Describe the solution you'd like..."
+    validations:
+      required: true
+
+  - type: markdown
+    attributes:
+      value: "## Describe alternatives you've considered"
+  - type: textarea
+    id: alternatives-considered
+    attributes:
+      label: Alternatives Considered
+      description: A clear and concise description of any alternative solutions or features you've considered.
+      placeholder: "Describe any alternative solutions or features you've considered..."
+    validations:
+      required: false
+
+  - type: markdown
+    attributes:
+      value: "## Additional context"
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional Context
+      description: Add any other context or screenshots about the feature request here.
+      placeholder: "Add any other context or screenshots about the feature request here..."
+    validations:
+      required: false

.github/workflows/docker.yml

@@ -0,0 +1,46 @@
+name: Publish Docker image
+
+on:
+  push:
+    tags:
+      # Push events matching v*, such as v1.0, v20.15.10, etc. to trigger workflows
+      - "v*"
+
+jobs:
+  push_to_registry:
+    name: Push Docker image to Docker Hub
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v3
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: xiangfa/deep-research
+          tags: |
+            type=raw,value=latest
+            type=ref,event=tag
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.github/workflows/ghcr.yml

@@ -0,0 +1,60 @@
+name: Create and publish a Docker image
+
+# Configures this workflow to run every time a change is pushed to the branch called `release`.
+on:
+  push:
+    tags:
+      # Push events matching v*, such as v1.0, v20.15.10, etc. to trigger workflows
+      - "v*"
+
+# Defines two custom environment variables for the workflow. These are used for the Container registry domain, and a name for the Docker image that this workflow builds.
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+# There is a single job in this workflow. It's configured to run on the latest available version of Ubuntu.
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+    # Sets the permissions granted to the `GITHUB_TOKEN` for the actions in this job.
+    permissions:
+      contents: read
+      packages: write
+      attestations: write
+      id-token: write
+      #
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      # Uses the `docker/login-action` action to log in to the Container registry registry using the account and password that will publish the packages. Once published, the packages are scoped to the account defined here.
+      - name: Log in to the Container registry
+        uses: docker/login-action@v2
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      # This step uses [docker/metadata-action](https://github.com/docker/metadata-action#about) to extract tags and labels that will be applied to the specified image. The `id` "meta" allows the output of this step to be referenced in a subsequent step. The `images` value provides the base name for the tags and labels.
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+      # This step uses the `docker/build-push-action` action to build the image, based on your repository's `Dockerfile`. If the build succeeds, it pushes the image to GitHub Packages.
+      # It uses the `context` parameter to define the build's context as the set of files located in the specified path. For more information, see [Usage](https://github.com/docker/build-push-action#usage) in the README of the `docker/build-push-action` repository.
+      # It uses the `tags` and `labels` parameters to tag and label the image with the output from the "meta" step.
+      - name: Build and push Docker image
+        id: push
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+
+      # This step generates an artifact attestation for the image, which is an unforgeable statement about where and how it was built. It increases supply chain security for people who consume the image. For more information, see [Using artifact attestations to establish provenance for builds](/actions/security-guides/using-artifact-attestations-to-establish-provenance-for-builds).
+      - name: Generate artifact attestation
+        uses: actions/attest-build-provenance@v2
+        with:
+          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}
+          subject-digest: ${{ steps.push.outputs.digest }}
+          push-to-registry: true

.github/workflows/issue-translator.yml

@@ -0,0 +1,15 @@
+name: Issue Translator
+on:
+  issue_comment:
+    types: [created]
+  issues:
+    types: [opened]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: usthe/issues-translate-action@v2.7
+        with:
+          IS_MODIFY_TITLE: false
+          CUSTOM_BOT_NOTE: Bot detected the issue body's language is not English, translate it automatically.

.github/workflows/sync.yml

@@ -0,0 +1,39 @@
+name: Upstream Sync
+
+permissions:
+  contents: write
+
+on:
+  schedule:
+    - cron: "0 4 * * *" # At 04:00, every day
+  workflow_dispatch:
+
+jobs:
+  sync_latest_from_upstream:
+    name: Sync latest commits from upstream repo
+    runs-on: ubuntu-latest
+    if: ${{ github.event.repository.fork }}
+
+    steps:
+      # Step 1: run a standard checkout action
+      - name: Checkout target repo
+        uses: actions/checkout@v3
+
+      # Step 2: run the sync action
+      - name: Sync upstream changes
+        id: sync
+        uses: aormsby/Fork-Sync-With-Upstream-action@v3.4
+        with:
+          upstream_sync_repo: u14app/deep-research
+          upstream_sync_branch: main
+          target_sync_branch: main
+          target_repo_token: ${{ secrets.GITHUB_TOKEN }} # automatically generated, no need to set
+
+          # Set test_mode true to run tests instead of the true action!!
+          test_mode: false
+
+      - name: Sync check
+        if: failure()
+        run: |
+          echo "[Error] Due to a change in the workflow file of the upstream repository, GitHub has automatically suspended the scheduled automatic update. You need to manually sync your fork."
+          exit 1

.gitignore

@@ -0,0 +1,45 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files (can opt-in for committing if needed)
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
+
+# Serwist
+public/sw*
+public/swe-worker*

.node-version

@@ -0,0 +1 @@
+18.18.0

.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+  "css.lint.unknownAtRules": "ignore",
+  "i18n-ally.localesPaths": ["src/locales"],
+  "i18n-ally.keystyle": "nested",
+  "i18n-ally.displayLanguage": "en-US",
+  "i18n-ally.sourceLanguage": "en-US"
+}

Dockerfile

@@ -0,0 +1,44 @@
+FROM node:18-alpine AS base
+
+# Install dependencies only when needed
+FROM base AS deps
+# Check https://github.com/nodejs/docker-node/tree/b4117f9333da4138b03a546ec926ef50a31506c3#nodealpine to understand why libc6-compat might be needed.
+RUN apk add --no-cache libc6-compat
+
+WORKDIR /app
+
+# Install dependencies based on the preferred package manager
+COPY package.json pnpm-lock.yaml ./
+RUN yarn global add pnpm && pnpm install --frozen-lockfile
+
+# Rebuild the source code only when needed
+FROM base AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+
+# Next.js collects completely anonymous telemetry data about general usage.
+# Learn more here: https://nextjs.org/telemetry
+# Uncomment the following line in case you want to disable telemetry during the build.
+# ENV NEXT_TELEMETRY_DISABLED 1
+
+RUN yarn run build:standalone
+
+# Production image, copy all the files and run next
+FROM base AS runner
+WORKDIR /app
+
+ENV NODE_ENV=production
+ENV NEXT_PUBLIC_BUILD_MODE=standalone
+
+# Automatically leverage output traces to reduce image size
+# https://nextjs.org/docs/advanced-features/output-file-tracing
+COPY --from=builder /app/.next/standalone ./
+COPY --from=builder /app/.next/static ./.next/static
+COPY --from=builder /app/public ./public
+
+EXPOSE 3000
+
+# server.js is created by next build from the standalone output
+# https://nextjs.org/docs/pages/api-reference/next-config-js/output
+CMD ["node", "server.js"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 u14app
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,459 @@
+<div align="center">
+<h1>Deep Research</h1>
+
+![GitHub deployments](https://img.shields.io/github/deployments/u14app/gemini-next-chat/Production)
+![GitHub Release](https://img.shields.io/github/v/release/u14app/deep-research)
+![Docker Image Size](https://img.shields.io/docker/image-size/xiangfa/deep-research/latest)
+![Docker Pulls](https://img.shields.io/docker/pulls/xiangfa/deep-research)
+[![License: MIT](https://img.shields.io/badge/License-MIT-default.svg)](https://opensource.org/licenses/MIT)
+
+[![Gemini](https://img.shields.io/badge/Gemini-8E75B2?style=flat&logo=googlegemini&logoColor=white)](https://ai.google.dev/)
+[![Next](https://img.shields.io/badge/Next.js-111111?style=flat&logo=nextdotjs&logoColor=white)](https://nextjs.org/)
+[![Tailwind CSS](https://img.shields.io/badge/Tailwind%20CSS-06B6D4?style=flat&logo=tailwindcss&logoColor=white)](https://tailwindcss.com/)
+[![shadcn/ui](https://img.shields.io/badge/shadcn/ui-111111?style=flat&logo=shadcnui&logoColor=white)](https://ui.shadcn.com/)
+
+[![Vercel](https://img.shields.io/badge/Vercel-111111?style=flat&logo=vercel&logoColor=white)](https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fu14app%2Fdeep-research&project-name=deep-research&repository-name=deep-research)
+[![Cloudflare](https://img.shields.io/badge/Cloudflare-F69652?style=flat&logo=cloudflare&logoColor=white)](./docs/How-to-deploy-to-Cloudflare-Pages.md)
+[![PWA](https://img.shields.io/badge/PWA-blue?style=flat&logo=pwa&logoColor=white)](https://research.u14.app/)
+
+</div>
+
+**Lightning-Fast Deep Research Report**
+
+Deep Research uses a variety of powerful AI models to generate in-depth research reports in just a few minutes. It leverages advanced "Thinking" and "Task" models, combined with an internet connection, to provide fast and insightful analysis on a variety of topics. **Your privacy is paramount - all data is processed and stored locally.**
+
+## ✨ Features
+
+- **Rapid Deep Research:** Generates comprehensive research reports in about 2 minutes, significantly accelerating your research process.
+- **Multi-platform Support:** Supports rapid deployment to Vercel, Cloudflare and other platforms.
+- **Powered by AI:** Utilizes the advanced AI models for accurate and insightful analysis.
+- **Privacy-Focused:** Your data remains private and secure, as all data is stored locally on your browser.
+- **Support for Multi-LLM:** Supports a variety of mainstream large language models, including Gemini, OpenAI, Anthropic, Deepseek, Grok, Mistral, Azure OpenAI, any OpenAI Compatible LLMs, OpenRouter, Ollama, etc.
+- **Support Web Search:** Supports search engines such as Searxng, Tavily, Firecrawl, Exa, Bocha, etc., allowing LLMs that do not support search to use the web search function more conveniently.
+- **Thinking & Task Models:** Employs sophisticated "Thinking" and "Task" models to balance depth and speed, ensuring high-quality results quickly. Support switching research models.
+- **Support Further Research:** You can refine or adjust the research content at any stage of the project and support re-research from that stage.
+- **Local Knowledge Base:** Supports uploading and processing text, Office, PDF and other resource files to generate local knowledge base.
+- **Artifact:** Supports editing of research content, with two editing modes: WYSIWYM and Markdown. It is possible to adjust the reading level, article length and full text translation.
+- **Knowledge Graph:** It supports one-click generation of knowledge graph, allowing you to have a systematic understanding of the report content.
+- **Research History:** Support preservation of research history, you can review previous research results at any time and conduct in-depth research again.
+- **Local & Server API Support:** Offers flexibility with both local and server-side API calling options to suit your needs.
+- **Support for SaaS and MCP:** You can use this project as a deep research service (SaaS) through the SSE API, or use it in other AI services through MCP service.
+- **Support PWA:** With Progressive Web App (PWA) technology, you can use the project like a software.
+- **Support Multi-Key payload:** Support Multi-Key payload to improve API response efficiency.
+- **Multi-language Support**: English, 简体中文, Español.
+- **Built with Modern Technologies:** Developed using Next.js 15 and Shadcn UI, ensuring a modern, performant, and visually appealing user experience.
+- **MIT Licensed:** Open-source and freely available for personal and commercial use under the MIT License.
+
+## 🎯 Roadmap
+
+- [x] Support preservation of research history
+- [x] Support editing final report and search results
+- [x] Support for other LLM models
+- [x] Support file upload and local knowledge base
+- [x] Support SSE API and MCP server
+
+## 🚀 Getting Started
+
+### Use Free Gemini (recommend)
+
+1. Get [Gemini API Key](https://aistudio.google.com/app/apikey)
+2. One-click deployment of the project, you can choose to deploy to Vercel or Cloudflare
+
+   [![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fu14app%2Fdeep-research&project-name=deep-research&repository-name=deep-research)
+
+   Currently the project supports deployment to Cloudflare, but you need to follow [How to deploy to Cloudflare Pages](./docs/How-to-deploy-to-Cloudflare-Pages.md) to do it.
+
+3. Start using
+
+### Use Other LLM
+
+1. Deploy the project to Vercel or Cloudflare
+2. Set the LLM API key
+3. Set the LLM API base URL (optional)
+4. Start using
+
+## ⌨️ Development
+
+Follow these steps to get Deep Research up and running on your local browser.
+
+### Prerequisites
+
+- [Node.js](https://nodejs.org/) (version 18.18.0 or later recommended)
+- [pnpm](https://pnpm.io/) or [npm](https://www.npmjs.com/) or [yarn](https://yarnpkg.com/)
+
+### Installation
+
+1. **Clone the repository:**
+
+   ```bash
+   git clone https://github.com/u14app/deep-research.git
+   cd deep-research
+   ```
+
+2. **Install dependencies:**
+
+   ```bash
+   pnpm install  # or npm install or yarn install
+   ```
+
+3. **Set up Environment Variables:**
+
+   You need to modify the file `env.tpl` to `.env`, or create a `.env` file and write the variables to this file.
+
+   ```bash
+   # For Development
+   cp env.tpl .env.local
+   # For Production
+   cp env.tpl .env
+   ```
+
+4. **Run the development server:**
+
+   ```bash
+   pnpm dev  # or npm run dev or yarn dev
+   ```
+
+   Open your browser and visit [http://localhost:3000](http://localhost:3000) to access Deep Research.
+
+### Custom Model List
+
+The project allow custom model list, but **only works in proxy mode**. Please add an environment variable named `NEXT_PUBLIC_MODEL_LIST` in the `.env` file or environment variables page.
+
+Custom model lists use `,` to separate multiple models. If you want to disable a model, use the `-` symbol followed by the model name, i.e. `-existing-model-name`. To only allow the specified model to be available, use `-all,+new-model-name`.
+
+## 🚢 Deployment
+
+### Vercel
+
+[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fu14app%2Fdeep-research&project-name=deep-research&repository-name=deep-research)
+
+### Cloudflare
+
+Currently the project supports deployment to Cloudflare, but you need to follow [How to deploy to Cloudflare Pages](./docs/How-to-deploy-to-Cloudflare-Pages.md) to do it.
+
+### Docker
+
+> The Docker version needs to be 20 or above, otherwise it will prompt that the image cannot be found.
+
+> ⚠️ Note: Most of the time, the docker version will lag behind the latest version by 1 to 2 days, so the "update exists" prompt will continue to appear after deployment, which is normal.
+
+```bash
+docker pull xiangfa/deep-research:latest
+docker run -d --name deep-research -p 3333:3000 xiangfa/deep-research
+```
+
+You can also specify additional environment variables:
+
+```bash
+docker run -d --name deep-research \
+   -p 3333:3000 \
+   -e ACCESS_PASSWORD=your-password \
+   -e GOOGLE_GENERATIVE_AI_API_KEY=AIzaSy... \
+   xiangfa/deep-research
+```
+
+or build your own docker image:
+
+```bash
+docker build -t deep-research .
+docker run -d --name deep-research -p 3333:3000 deep-research
+```
+
+If you need to specify other environment variables, please add `-e key=value` to the above command to specify it.
+
+Deploy using `docker-compose.yml`:
+
+```bash
+version: '3.9'
+services:
+   deep-research:
+      image: xiangfa/deep-research
+      container_name: deep-research
+      environment:
+         - ACCESS_PASSWORD=your-password
+         - GOOGLE_GENERATIVE_AI_API_KEY=AIzaSy...
+      ports:
+         - 3333:3000
+```
+
+or build your own docker compose:
+
+```bash
+docker compose -f docker-compose.yml build
+```
+
+### Static Deployment
+
+You can also build a static page version directly, and then upload all files in the `out` directory to any website service that supports static pages, such as Github Page, Cloudflare, Vercel, etc..
+
+```bash
+pnpm build:export
+```
+
+## ⚙️ Configuration
+
+As mentioned in the "Getting Started" section, Deep Research utilizes the following environment variables for server-side API configurations:
+
+Please refer to the file [env.tpl](./env.tpl) for all available environment variables.
+
+**Important Notes on Environment Variables:**
+
+- **Privacy Reminder:** These environment variables are primarily used for **server-side API calls**. When using the **local API mode**, no API keys or server-side configurations are needed, further enhancing your privacy.
+
+- **Multi-key Support:** Supports multiple keys, each key is separated by `,`, i.e. `key1,key2,key3`.
+
+- **Security Setting:** By setting `ACCESS_PASSWORD`, you can better protect the security of the server API.
+
+- **Make variables effective:** After adding or modifying this environment variable, please redeploy the project for the changes to take effect.
+
+## 📄 API documentation
+
+Currently the project supports two forms of API: Server-Sent Events (SSE) and Model Context Protocol (MCP).
+
+### Server-Sent Events API
+
+The Deep Research API provides a real-time interface for initiating and monitoring complex research tasks.
+
+Recommended to use the API via `@microsoft/fetch-event-source`, to get the final report, you need to listen to the `message` event, the data will be returned in the form of a text stream.
+
+#### POST method
+
+Endpoint: `/api/sse`
+
+Method: `POST`
+
+Body:
+
+```typescript
+interface SSEConfig {
+  // Research topic
+  query: string;
+  // AI provider, Possible values ​​include: google, openai, anthropic, deepseek, xai, mistral, azure, openrouter, openaicompatible, pollinations, ollama
+  provider: string;
+  // Thinking model id
+  thinkingModel: string;
+  // Task model id
+  taskModel: string;
+  // Search provider, Possible values ​​include: model, tavily, firecrawl, exa, bocha, searxng
+  searchProvider: string;
+  // Response Language, also affects the search language. (optional)
+  language?: string;
+  // Maximum number of search results. Default, `5` (optional)
+  maxResult?: number;
+  // Whether to include content-related images in the final report. Default, `true`. (optional)
+  enableCitationImage?: boolean;
+  // Whether to include citation links in search results and final reports. Default, `true`. (optional)
+  enableReferences?: boolean;
+}
+```
+
+Headers:
+
+```typescript
+interface Headers {
+  "Content-Type": "application/json";
+  // If you set an access password
+  // Authorization: "Bearer YOUR_ACCESS_PASSWORD";
+}
+```
+
+See the detailed [API documentation](./docs/deep-research-api-doc.md).
+
+#### GET method
+
+This is an interesting implementation. You can watch the whole process of deep research directly through the URL just like watching a video.
+
+You can access the deep research report via the following link:
+
+```text
+http://localhost:3000/api/sse/live?query=AI+trends+for+this+year&provider=pollinations&thinkingModel=openai&taskModel=openai-fast&searchProvider=searxng
+```
+
+Query Params:
+
+```typescript
+// The parameters are the same as POST parameters
+interface QueryParams extends SSEConfig {
+  // If you set the `ACCESS_PASSWORD` environment variable, this parameter is required
+  password?: string;
+}
+```
+
+### Model Context Protocol (MCP) Server
+
+Currently supports `StreamableHTTP` and `SSE` Server Transport.
+
+StreamableHTTP server endpoint: `/api/mcp`, transport type: `streamable-http`
+
+SSE server endpoint: `/api/mcp/sse`, transport type: `sse`
+
+```json
+{
+  "mcpServers": {
+    "deep-research": {
+      "url": "http://127.0.0.1:3000/api/mcp",
+      "transportType": "streamable-http",
+      "timeout": 600
+    }
+  }
+}
+```
+
+**Note:** Since deep research take a long time to execute, you need to set a longer timeout to avoid interrupting the study.
+
+If your server sets `ACCESS_PASSWORD`, the MCP service will be protected and you need to add additional headers parameters:
+
+```json
+{
+  "mcpServers": {
+    "deep-research": {
+      "url": "http://127.0.0.1:3000/api/mcp",
+      "transportType": "streamable-http",
+      "timeout": 600,
+      "headers": {
+        "Authorization": "Bearer YOUR_ACCESS_PASSWORD"
+      }
+    }
+  }
+}
+```
+
+**Enabling MCP service requires setting global environment variables:**
+
+```bash
+# MCP Server AI provider
+# Possible values ​​include: google, openai, anthropic, deepseek, xai, mistral, azure, openrouter, openaicompatible, pollinations, ollama
+MCP_AI_PROVIDER=google
+# MCP Server search provider. Default, `model`
+# Possible values ​​include: model, tavily, firecrawl, exa, bocha, searxng
+MCP_SEARCH_PROVIDER=tavily
+# MCP Server thinking model id, the core model used in deep research.
+MCP_THINKING_MODEL=gemini-2.0-flash-thinking-exp
+# MCP Server task model id, used for secondary tasks, high output models are recommended.
+MCP_TASK_MODEL=gemini-2.0-flash-exp
+```
+
+**Note:** To ensure that the MCP service can be used normally, you need to set the environment variables of the corresponding model and search engine. For specific environment variable parameters, please refer to [env.tpl](./env.tpl).
+
+## 🪄 How it works
+
+1. **Research topic**
+
+   - Input research topic
+   - Use local research resources (optional)
+   - Start thinking (or rethinking)
+
+2. **Propose your ideas**
+
+   - The system asks questions
+     - Answer system questions (optional)
+     - Write a research plan (or rewrite the research plan)
+   - The system outputs the research plan
+     - Start in-depth research (or re-research)
+     - The system generates SERP queries
+
+3. **Information collection**
+
+   - Initial research
+     - Retrieve local research resources based on SERP queries
+     - Collect information from the Internet based on SERP queries
+   - In-depth research (this process can be repeated)
+     - Propose research suggestions (optional)
+     - Start a new round of information collection (the process is the same as the initial research)
+
+4. **Generate Final Report**
+
+   - Make a writing request (optional)
+   - Summarize all research materials into a comprehensive Markdown report
+   - Regenerate research report (optional)
+
+```mermaid
+flowchart TB
+    A[Research Topic]:::start
+
+    subgraph Propose[Propose your ideas]
+        B1[System asks questions]:::process
+        B2[System outputs the research plan]:::process
+        B3[System generates SERP queries]:::process
+        B1 --> B2
+        B2 --> B3
+    end
+
+    subgraph Collect[Information collection]
+        C1[Initial research]:::collection
+        C1a[Retrieve local research resources based on SERP queries]:::collection
+        C1b[Collect information from the Internet based on SERP queries]:::collection
+        C2[In-depth research]:::recursive
+        Refine{More in-depth research needed?}:::decision
+
+        C1 --> C1a
+        C1 --> C1b
+        C1a --> C2
+        C1b --> C2
+        C2 --> Refine
+        Refine -->|Yes| C2
+    end
+
+    Report[Generate Final Report]:::output
+
+    A --> Propose
+    B3 --> C1
+
+    %% Connect the exit from the loop/subgraph to the final report
+    Refine -->|No| Report
+
+    %% Styling
+    classDef start fill:#7bed9f,stroke:#2ed573,color:black
+    classDef process fill:#70a1ff,stroke:#1e90ff,color:black
+    classDef recursive fill:#ffa502,stroke:#ff7f50,color:black
+    classDef output fill:#ff4757,stroke:#ff6b81,color:black
+    classDef collection fill:#a8e6cf,stroke:#3b7a57,color:black
+    classDef decision fill:#c8d6e5,stroke:#8395a7,color:black
+
+    class A start
+    class B1,B2,B3 process
+    class C1,C1a,C1b collection
+    class C2 recursive
+    class Refine decision
+    class Report output
+```
+
+## 🙋 FAQs
+
+**Why does my Ollama or SearXNG not work properly and displays the error `TypeError: Failed to fetch`?**
+
+If your request generates `CORS` due to browser security restrictions, you need to configure parameters for Ollama or SearXNG to allow cross-domain requests. You can also consider using the server proxy mode, which is a backend server that makes requests, which can effectively avoid cross-domain issues.
+
+## 🛡️ Privacy
+
+Deep Research is designed with your privacy in mind. **All research data and generated reports are stored locally on your machine.** We do not collect or transmit any of your research data to external servers (unless you are explicitly using server-side API calls, in which case data is sent to API through your configured proxy if any). Your privacy is our priority.
+
+## 🙏 Acknowledgements
+
+- [Next.js](https://nextjs.org/) - The React framework for building performant web applications.
+- [Shadcn UI](https://ui.shadcn.com/) - Beautifully designed components that helped streamline the UI development.
+- [AI SDKs](https://sdk.vercel.ai) - Powering the intelligent research capabilities of Deep Research.
+- [Deep Research](https://github.com/dzhng/deep-research) - Thanks to the project `dzhng/deep-research` for inspiration.
+
+## 🤝 Contributing
+
+We welcome contributions to Deep Research! If you have ideas for improvements, bug fixes, or new features, please feel free to:
+
+1. Fork the repository.
+2. Create a new branch for your feature or bug fix.
+3. Make your changes and commit them.
+4. Submit a pull request.
+
+For major changes, please open an issue first to discuss your proposed changes.
+
+## ✉️ Contact
+
+If you have any questions, suggestions, or feedback, please create a new [issue](https://github.com/u14app/deep-research/issues).
+
+## 🌟 Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=u14app/deep-research&type=Date)](https://www.star-history.com/#u14app/deep-research&Date)
+
+## 📝 License
+
+Deep Research is released under the [MIT License](LICENSE). This license allows for free use, modification, and distribution for both commercial and non-commercial purposes.

components.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": true,
+  "tsx": true,
+  "tailwind": {
+    "config": "tailwind.config.ts",
+    "css": "src/app/globals.css",
+    "baseColor": "slate",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/utils/style",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "iconLibrary": "lucide"
+}

docker-compose.yml

@@ -0,0 +1,12 @@
+version: "3.9"
+services:
+  deep-research:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    image: deep-research
+    container_name: deep-research
+    env_file:
+      - .env
+    ports:
+      - "3333:3000"

docs/How-to-deploy-to-Cloudflare-Pages.md

@@ -0,0 +1,14 @@
+### How to deploy your project to Cloudflare Pages
+
+1. Log in to the Cloudflare dashboard and select your account.
+2. Select Compute(Workers) > Create > Pages.
+3. Click Connect to Git > deep-research > Begin Setup
+4. Framework preset > `Next.js` > Set Environment Variables (optional) > Save and Deploy
+5. Deploy > Redeploy
+
+### Set a custom domain name (optional)
+
+Since the `pages.dev` domain name cannot be accessed normally in some countries, you can solve this problem by setting a custom domain name.
+
+1. Select Compute(Workers) > Your project.
+2. Select Custom Domains > Set up a custom domain.

docs/deep-research-api-doc.md

@@ -0,0 +1,332 @@
+# Deep Research API Documentation
+
+## Overview
+
+The Deep Research API provides a real-time interface for initiating and monitoring complex research tasks. Leveraging Server-Sent Events (SSE), it delivers updates, information, message, progress, and errors as they occur, allowing clients to receive continuous streams of data without polling.
+
+## Protocol
+
+This API uses **Server-Sent Events (SSE)** over HTTP. Clients should establish an HTTP connection and keep it open to receive a stream of events from the server.
+
+## Data Format
+
+All data sent via SSE adheres to the following structure:
+
+```text
+event: EventName
+data: JSON_String
+
+```
+
+- `event`: Specifies the type of event being sent (e.g., `infor`, `message`, `reasoning`, `progress`, `error`).
+- `data`: A string containing a JSON object relevant to the event type.
+- A double newline (`\n\n`) signifies the end of an event block.
+
+## API config
+
+Recommended to use the API via `@microsoft/fetch-event-source`.
+
+Endpoint: `/api/sse`
+
+Method: `POST`
+
+Body:
+
+```typescript
+interface Config {
+  // Research topic
+  query: string;
+  // AI provider, Possible values ​​include: google, openai, anthropic, deepseek, xai, mistral, azure, openrouter, openaicompatible, pollinations, ollama
+  provider: string;
+  // Thinking model id
+  thinkingModel: string;
+  // Task model id
+  taskModel: string;
+  // Search provider, Possible values ​​include: model, tavily, firecrawl, exa, bocha, searxng
+  searchProvider: string;
+  // Response Language, also affects the search language. (optional)
+  language?: string;
+  // Maximum number of search results. Default, `5` (optional)
+  maxResult?: number;
+  // Whether to include content-related images in the final report. Default, `true`. (optional)
+  enableCitationImage?: boolean;
+  // Whether to include citation links in search results and final reports. Default, `true`. (optional)
+  enableReferences?: boolean;
+}
+```
+
+Headers:
+
+```typescript
+interface Headers {
+  "Content-Type": "application/json";
+  // If you set an access password
+  // Authorization: "Bearer YOUR_ACCESS_PASSWORD";
+}
+```
+
+For specific usage parameter forms, see the [example code](#client-code-example).
+
+## Response Events
+
+The API streams data as a series of events. Each event has a type (`event`) and associated data (`data`).
+
+### General Structure
+
+```text
+event: [event_type]
+data: [JSON_payload]
+
+```
+
+### Event Types
+
+The following event types are supported:
+
+- `infor`
+- `message`
+- `reasoning`
+- `progress`
+- `error`
+
+---
+
+### `infor` Event
+
+Sent at the beginning of the stream (or upon specific requests) to provide initial information about the API instance or the research session.
+
+**Description:** Provides basic information about the running API instance.
+
+**Data Structure (`data` field):** A JSON string representing the following structure:
+
+| Parameter | Type   | Description         |
+| :-------- | :----- | :------------------ |
+| `name`    | string | Project name        |
+| `version` | string | Current API version |
+
+```typescript
+interface InforEvent {
+  // Project name
+  name: string;
+  // Current API version
+  version: string;
+}
+```
+
+**Example:**
+
+```text
+event: infor
+data: {"name":"deep-research","version":"0.1.0"}
+
+```
+
+---
+
+### `message` Event
+
+Used to send text content of deep research to the client.
+
+**Description:** Delivers textual messages during the research process.
+
+**Data Structure (`data` field):** A JSON string representing the following structure:
+
+| Parameter | Type   | Description                            | Notes                                                 |
+| :-------- | :----- | :------------------------------------- | :---------------------------------------------------- |
+| `type`    | string | Type of the message content            | Currently only `"text"` is supported.                 |
+| `text`    | string | The message content (Markdown format). | Optional for future types, but required for `"text"`. |
+
+```typescript
+interface MessageEvent {
+  // Message type, currently only "text" is supported
+  type: "text";
+  // Textual data
+  text?: string;
+}
+```
+
+**Example:**
+
+```text
+event: message
+data: {"type":"text","text":"This is a **markdown** string."}
+
+```
+
+---
+
+### `reasoning` Event
+
+Used to send thinking content of deep research to the client. Some thinking models support output thinking process.
+
+**Description:** Delivers textual messages during the research process.
+
+**Data Structure (`data` field):** A JSON string representing the following structure:
+
+| Parameter | Type   | Description                              | Notes                                 |
+| :-------- | :----- | :--------------------------------------- | :------------------------------------ |
+| `type`    | string | Type of the reasoning content            | Currently only `"text"` is supported. |
+| `text`    | string | The reasoning content (Markdown format). | Required for `"text"`.                |
+
+```typescript
+interface ReasoningEvent {
+  // Reasoning type, currently only "text" is supported
+  type: "text";
+  // Textual data
+  text: string;
+}
+```
+
+**Example:**
+
+```text
+event: message
+data: {"type":"text","text":"Output thinking process"}
+
+```
+
+---
+
+### `progress` Event
+
+Communicates the current step and status of the research task execution. This is crucial for providing real-time feedback on the process flow.
+
+**Description:** Indicates the progress of the research task, including the current step and its status (start or end).
+
+**Data Structure (`data` field):** A JSON string representing the following structure:
+
+| Parameter | Type                                                                            | Description                                                                                  | Notes                                                                              |
+| :-------- | :------------------------------------------------------------------------------ | :------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------- |
+| `step`    | "report-plan" \| "serp-query" \| "task-list" \| "search-task" \| "final-report" | The identifier of the current step in the research process.                                  | See "Possible `step` Values" below.                                                |
+| `status`  | "start" \| "end"                                                                | The status of the current step.                                                              | Indicates if the step is starting or ending. See "Possible `status` Values" below. |
+| `name`    | string                                                                          | A descriptive name for the specific instance of the step (e.g., for a specific search task). | Included only when `step` is `"search-task"`.                                      |
+| `data`    | any                                                                             | Optional data relevant to the step's outcome or details.                                     | May be included when `status` is `"end"`. The content varies by step.              |
+
+```typescript
+interface ProgressEvent {
+  // Current step
+  step:
+    | "report-plan"
+    | "serp-query"
+    | "task-list"
+    | "search-task"
+    | "final-report";
+  // Status of the step
+  status: "start" | "end";
+  // Name of the specific task (e.g., search query)
+  name?: string;
+  // Data related to the step's outcome or details
+  data?: any;
+}
+```
+
+**Possible `step` Values:**
+
+- `report-plan`: The system is generating or processing the overall report plan.
+- `serp-query`: The system is performing a Search Engine Results Page (SERP) query.
+- `task-list`: The system is generating or processing a list of specific research tasks.
+- `search-task`: The system is executing a specific search task. This step includes the `name` parameter.
+- `final-report`: The system is compiling or finalizing the comprehensive research report.
+
+**Possible `status` Values:**
+
+- `start`: Indicates that the specified `step` has just begun.
+- `end`: Indicates that the specified `step` has just finished.
+
+**Example:**
+
+```text
+event: progress
+data: {"step":"search-task","status":"start","name":"AI trends for this year"}
+
+event: progress
+data: {"step":"search-task","status":"end","name":"AI trends for this year","data":{"results_count": 15}}
+
+```
+
+---
+
+### `error` Event
+
+Sent when an error occurs during the research process that prevents the task from completing successfully or requires user attention.
+
+**Description:** Signals that an error has occurred.
+
+**Data Structure (`data` field):** A JSON string typically containing information about the error. A common structure is:
+
+| Parameter | Type   | Description                                | Notes |
+| :-------- | :----- | :----------------------------------------- | :---- |
+| `message` | string | A human-readable description of the error. |       |
+
+```typescript
+interface ErrorEvent {
+  // A human-readable description of the error.
+  message: string;
+}
+```
+
+**Example:**
+
+```text
+event: error
+data: {"message":"Invalid query parameters."}
+
+```
+
+---
+
+## Error Handling
+
+Clients should always listen for the `error` event. Upon receiving an `error` event, the client should typically display the error message to the user and may consider the current research task terminated unless otherwise specified by the API's behavior.
+
+## Client Code Example
+
+This example demonstrates how to connect to the SSE endpoint using `EventSource` API and listen for the defined event types, specifically focusing on displaying `message` events.
+
+```typescript
+import { fetchEventSource } from "@microsoft/fetch-event-source";
+
+const ctrl = new AbortController();
+
+let report = "";
+fetchEventSource("/api/sse", {
+  method: "POST",
+  headers: {
+    "Content-Type": "application/json",
+    // If you set an access password
+    // Authorization: "Bearer YOUR_ACCESS_PASSWORD",
+  },
+  body: JSON.stringify({
+    query: "AI trends for this year",
+    provider: "google",
+    thinkingModel: "gemini-2.0-flash-thinking-exp",
+    taskModel: "gemini-2.0-flash-exp",
+    searchProvider: "model",
+    language: "en-US",
+    maxResult: 5,
+    enableCitationImage: true,
+    enableReferences: true,
+  }),
+  signal: ctrl.signal,
+  onmessage(msg) {
+    const msgData = JSON.parse(msg.data);
+    if (msg.event === "message") {
+      if (msgData.type === "text") {
+        report += msgData.text;
+      }
+    } else if (msg.event === "progress") {
+      console.log(
+        `[${data.step}]: ${msgData.name ? `${msgData.name} ` : ""}${
+          msgData.status
+        }`
+      );
+      if (msgData.data) console.log(msgData.data);
+    } else if (msg.event === "error") {
+      throw new Error(msgData.message);
+    }
+  },
+  onclose() {
+    console.log(report);
+  },
+});
+```

env.tpl

@@ -0,0 +1,101 @@
+# (Optional) Server API Access Password for enhanced security
+ACCESS_PASSWORD=
+
+# (Optional) Server-side Gemini API Key (Required for server API calls)
+GOOGLE_GENERATIVE_AI_API_KEY=
+# (Optional) Server-side Gemini API Proxy URL. Default, `https://generativelanguage.googleapis.com`
+GOOGLE_GENERATIVE_AI_API_BASE_URL=
+# (Deprecated) Server-side Gemini API Proxy URL. Default, `https://generativelanguage.googleapis.com`
+API_PROXY_BASE_URL=
+
+# (Optional) Server-side OpenRouter API Key (Required for server API calls)
+OPENROUTER_API_KEY=
+# (Optional) Server-side OpenRouter API Proxy URL. Default, `https://openrouter.ai`
+OPENROUTER_API_BASE_URL=
+
+# (Optional) Server-side OpenAI API Key (Required for server API calls)
+OPENAI_API_KEY=
+# (Optional) Server-side OpenAI API Proxy URL. Default, `https://api.openai.com`
+OPENAI_API_BASE_URL=
+
+# (Optional) Server-side Anthropic API Key (Required for server API calls)
+ANTHROPIC_API_KEY=
+# (Optional) Server-side Anthropic API Proxy URL. Default, `https://api.anthropic.com`
+ANTHROPIC_API_BASE_URL=
+
+# (Optional) Server-side DeepSeek API Key (Required for server API calls)
+DEEPSEEK_API_KEY=
+# (Optional) Server-side DeepSeek API Proxy URL. Default, `https://api.deepseek.com`
+DEEPSEEK_API_BASE_URL=
+
+# (Optional) Server-side XAI API Key (Required for server API calls)
+XAI_API_KEY=
+# (Optional) Server-side XAI API Proxy URL. Default, `https://api.x.ai`
+XAI_API_BASE_URL=
+
+# (Optional) Server-side Mistral API Key (Required for server API calls)
+MISTRAL_API_KEY=
+# (Optional) Server-side Mistral API Proxy URL. Default, `https://api.mistral.ai`
+MISTRAL_API_BASE_URL=
+
+# (Optional) Server-side Azure API Key (Required for server API calls)
+AZURE_API_KEY=
+# (Optional) Server-side Azure Resource Name. The resource name is used in the assembled URL: `https://{AZURE_RESOURCE_NAME}.openai.azure.com/openai/deployments`
+AZURE_RESOURCE_NAME=
+
+# (Optional) Server-side Compatible with OpenAI API Key (Required for server API calls)
+OPENAI_COMPATIBLE_API_KEY=
+# (Optional) Server-side Compatible with OpenAI API Proxy URL.
+OPENAI_COMPATIBLE_API_BASE_URL=
+
+# (Optional) Server-side pollinations.ai API Proxy URL. Default, `https://text.pollinations.ai/openai`
+POLLINATIONS_API_BASE_URL=
+
+# (Optional) Server-side Ollama API Proxy URL. Default, `http://0.0.0.0:11434`
+OLLAMA_API_BASE_URL=
+
+# (Optional) Server-side Tavily API Key (Required for server API calls)
+TAVILY_API_KEY=
+# (Optional) Server-side Tavily API Proxy URL. Default, `https://api.tavily.com`
+TAVILY_API_BASE_URL=
+
+# (Optional) Server-side Firecrawl API Key (Required for server API calls)
+FIRECRAWL_API_KEY=
+# (Optional) Server-side Firecrawl API Proxy URL. Default, `https://api.firecrawl.dev`
+FIRECRAWL_API_BASE_URL=
+
+# (Optional) Server-side Exa API Key (Required for server API calls)
+EXA_API_KEY=
+# (Optional) Server-side Exa API Proxy URL. Default, `https://api.exa.ai`
+EXA_API_BASE_URL=
+
+# (Optional) Server-side Bocha API Key (Required for server API calls)
+BOCHA_API_KEY=
+# (Optional) Server-side Bocha API Proxy URL. Default, `https://api.bochaai.com`
+BOCHA_API_BASE_URL=
+
+# (Optional) Server-side Searxng API Proxy URL. Default, `http://0.0.0.0:8080`
+SEARXNG_API_BASE_URL=
+
+# (Optional) MCP Server AI provider
+# Possible values ​​include: google, openai, anthropic, deepseek, xai, mistral, azure, openrouter, openaicompatible, pollinations, ollama
+MCP_AI_PROVIDER=
+# (Optional) MCP Server search provider. Default, `model`
+# Possible values ​​include: model, tavily, firecrawl, exa, bocha, searxng
+MCP_SEARCH_PROVIDER=
+# (Optional) MCP Server thinking model id, the core model used in deep research.
+MCP_THINKING_MODEL=
+# (Optional) MCP Server task model id, used for secondary tasks, high output models are recommended.
+MCP_TASK_MODEL=
+
+# (Optional) Disable server-side AI provider usage permissions
+# Possible values ​​include: google, openai, anthropic, deepseek, xai, mistral, azure, openrouter, openaicompatible, pollinations, ollama
+NEXT_PUBLIC_DISABLED_AI_PROVIDER=
+# (Optional) Disable server-side search provider usage permissions
+# Possible values ​​include: model, tavily, firecrawl, exa, bocha, searxng
+NEXT_PUBLIC_DISABLED_SEARCH_PROVIDER=
+# (Optional) Customize the model list, add or delete models
+NEXT_PUBLIC_MODEL_LIST=
+
+# (Optional) Injected script code can be used for statistics or error tracking.
+HEAD_SCRIPTS=

eslint.config.mjs

@@ -0,0 +1,21 @@
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+});
+
+const eslintConfig = [
+  ...compat.extends("next/core-web-vitals", "next/typescript"),
+  {
+    rules: {
+      "@typescript-eslint/no-explicit-any": "off",
+    },
+  },
+];
+
+export default eslintConfig;

next.config.ts

@@ -0,0 +1,158 @@
+import type { NextConfig } from "next";
+import withSerwistInit from "@serwist/next";
+import { PHASE_PRODUCTION_BUILD } from "next/constants.js";
+import pkg from "./package.json";
+
+const BUILD_MODE = process.env.NEXT_PUBLIC_BUILD_MODE;
+// AI provider API base url
+const API_PROXY_BASE_URL = process.env.API_PROXY_BASE_URL || "";
+const GOOGLE_GENERATIVE_AI_API_BASE_URL =
+  process.env.GOOGLE_GENERATIVE_AI_API_BASE_URL ||
+  "https://generativelanguage.googleapis.com";
+const OPENROUTER_API_BASE_URL =
+  process.env.OPENROUTER_API_BASE_URL || "https://openrouter.ai/api";
+const OPENAI_API_BASE_URL =
+  process.env.OPENAI_API_BASE_URL || "https://api.openai.com";
+const ANTHROPIC_API_BASE_URL =
+  process.env.ANTHROPIC_API_BASE_URL || "https://api.anthropic.com";
+const DEEPSEEK_API_BASE_URL =
+  process.env.DEEPSEEK_API_BASE_URL || "https://api.deepseek.com";
+const XAI_API_BASE_URL = process.env.XAI_API_BASE_URL || "https://api.x.ai";
+const MISTRAL_API_BASE_URL =
+  process.env.MISTRAL_API_BASE_URL || "https://api.mistral.ai";
+const AZURE_API_BASE_URL = `https://${process.env.AZURE_RESOURCE_NAME}.openai.azure.com/openai/deployments`;
+const OPENAI_COMPATIBLE_API_BASE_URL =
+  process.env.OPENAI_COMPATIBLE_API_BASE_URL || "";
+const POLLINATIONS_API_BASE_URL =
+  process.env.POLLINATIONS_API_BASE_URL ||
+  "https://text.pollinations.ai/openai";
+const OLLAMA_API_BASE_URL =
+  process.env.OLLAMA_API_BASE_URL || "http://0.0.0.0:11434";
+// Search provider API base url
+const TAVILY_API_BASE_URL =
+  process.env.TAVILY_API_BASE_URL || "https://api.tavily.com";
+const FIRECRAWL_API_BASE_URL =
+  process.env.FIRECRAWL_API_BASE_URL || "https://api.firecrawl.dev";
+const EXA_API_BASE_URL = process.env.EXA_API_BASE_URL || "https://api.exa.ai";
+const BOCHA_API_BASE_URL =
+  process.env.BOCHA_API_BASE_URL || "https://api.bochaai.com";
+const SEARXNG_API_BASE_URL =
+  process.env.SEARXNG_API_BASE_URL || "http://0.0.0.0:8080";
+
+export default async function Config(phase: string) {
+  const nextConfig: NextConfig = {
+    /* config options here */
+    experimental: {
+      reactCompiler: true,
+    },
+    env: {
+      NEXT_PUBLIC_VERSION: pkg.version,
+    },
+    transpilePackages: ["pdfjs-dist", "mermaid"],
+  };
+
+  if (BUILD_MODE === "export") {
+    nextConfig.output = "export";
+    // Only used for static deployment, the default deployment directory is the root directory
+    nextConfig.basePath = "";
+    // Statically exporting a Next.js application via `next export` disables API routes and middleware.
+    nextConfig.webpack = (config) => {
+      config.module.rules.push({
+        test: /src\/app\/api/,
+        loader: "ignore-loader",
+      });
+      config.module.rules.push({
+        test: /src\/middleware/,
+        loader: "ignore-loader",
+      });
+      return config;
+    };
+  } else if (BUILD_MODE === "standalone") {
+    nextConfig.output = "standalone";
+  } else {
+    nextConfig.rewrites = async () => {
+      return [
+        {
+          source: "/api/ai/google/:path*",
+          destination: `${
+            GOOGLE_GENERATIVE_AI_API_BASE_URL || API_PROXY_BASE_URL
+          }/:path*`,
+        },
+        {
+          source: "/api/ai/openrouter/:path*",
+          destination: `${OPENROUTER_API_BASE_URL}/:path*`,
+        },
+        {
+          source: "/api/ai/openai/:path*",
+          destination: `${OPENAI_API_BASE_URL}/:path*`,
+        },
+        {
+          source: "/api/ai/anthropic/:path*",
+          destination: `${ANTHROPIC_API_BASE_URL}/:path*`,
+        },
+        {
+          source: "/api/ai/deepseek/:path*",
+          destination: `${DEEPSEEK_API_BASE_URL}/:path*`,
+        },
+        {
+          source: "/api/ai/xai/:path*",
+          destination: `${XAI_API_BASE_URL}/:path*`,
+        },
+        {
+          source: "/api/ai/mistral/:path*",
+          destination: `${MISTRAL_API_BASE_URL}/:path*`,
+        },
+        {
+          source: "/api/ai/azure/:path*",
+          destination: `${AZURE_API_BASE_URL}/:path*`,
+        },
+        {
+          source: "/api/ai/openaicompatible/:path*",
+          destination: `${OPENAI_COMPATIBLE_API_BASE_URL}/:path*`,
+        },
+        {
+          source: "/api/ai/pollinations/:path*",
+          destination: `${POLLINATIONS_API_BASE_URL}/:path*`,
+        },
+        {
+          source: "/api/ai/ollama/:path*",
+          destination: `${OLLAMA_API_BASE_URL}/:path*`,
+        },
+        {
+          source: "/api/search/tavily/:path*",
+          destination: `${TAVILY_API_BASE_URL}/:path*`,
+        },
+        {
+          source: "/api/search/firecrawl/:path*",
+          destination: `${FIRECRAWL_API_BASE_URL}/:path*`,
+        },
+        {
+          source: "/api/search/exa/:path*",
+          destination: `${EXA_API_BASE_URL}/:path*`,
+        },
+        {
+          source: "/api/search/bocha/:path*",
+          destination: `${BOCHA_API_BASE_URL}/:path*`,
+        },
+        {
+          source: "/api/search/searxng/:path*",
+          destination: `${SEARXNG_API_BASE_URL}/:path*`,
+        },
+      ];
+    };
+  }
+
+  if (phase === PHASE_PRODUCTION_BUILD) {
+    const withSerwist = withSerwistInit({
+      // Note: This is only an example. If you use Pages Router,
+      // use something else that works, such as "service-worker/index.ts".
+      swSrc: "src/app/sw.ts",
+      swDest: "public/sw.js",
+      register: false,
+    });
+
+    return withSerwist(nextConfig);
+  }
+
+  return nextConfig;
+}

package.json

@@ -0,0 +1,114 @@
+{
+  "name": "deep-research",
+  "description": "Use any LLMs (Large Language Models) for Deep Research. Support SSE API and MCP server.",
+  "version": "0.9.18",
+  "license": "MIT",
+  "repository": {
+    "url": "https://github.com/u14app/deep-research"
+  },
+  "bugs": "https://github.com/u14app/deep-research/issues",
+  "private": true,
+  "scripts": {
+    "dev": "next dev --turbopack",
+    "build": "next build",
+    "build:standalone": "cross-env NEXT_PUBLIC_BUILD_MODE=standalone next build",
+    "build:export": "cross-env NEXT_PUBLIC_BUILD_MODE=export next build",
+    "start": "next start",
+    "lint": "next lint"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^1.2.10",
+    "@ai-sdk/azure": "^1.3.23",
+    "@ai-sdk/deepseek": "^0.2.13",
+    "@ai-sdk/google": "^1.2.14",
+    "@ai-sdk/mistral": "^1.2.8",
+    "@ai-sdk/openai": "^1.3.21",
+    "@ai-sdk/openai-compatible": "^0.2.14",
+    "@ai-sdk/ui-utils": "^1.2.9",
+    "@ai-sdk/xai": "^1.2.15",
+    "@hookform/resolvers": "^4.1.2",
+    "@openrouter/ai-sdk-provider": "^0.4.5",
+    "@radix-ui/react-accordion": "^1.2.3",
+    "@radix-ui/react-dialog": "^1.1.6",
+    "@radix-ui/react-dropdown-menu": "^2.1.6",
+    "@radix-ui/react-label": "^2.1.2",
+    "@radix-ui/react-popover": "^1.1.6",
+    "@radix-ui/react-scroll-area": "^1.2.6",
+    "@radix-ui/react-select": "^2.1.6",
+    "@radix-ui/react-separator": "^1.1.2",
+    "@radix-ui/react-slider": "^1.2.3",
+    "@radix-ui/react-slot": "^1.1.2",
+    "@radix-ui/react-tabs": "^1.1.3",
+    "@radix-ui/react-tooltip": "^1.1.8",
+    "@serwist/next": "^9.0.14",
+    "@xiangfa/mdeditor": "^0.2.3",
+    "@zip.js/zip.js": "^2.7.60",
+    "ai": "^4.3.12",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "copy-to-clipboard": "^3.3.3",
+    "dayjs": "^1.11.13",
+    "file-saver": "^2.0.5",
+    "fuse.js": "^7.1.0",
+    "i18next": "^24.2.3",
+    "i18next-browser-languagedetector": "^8.0.4",
+    "i18next-resources-to-backend": "^1.2.1",
+    "katex": "^0.16.22",
+    "localforage": "^1.10.0",
+    "lucide-react": "^0.475.0",
+    "marked": "^15.0.12",
+    "mermaid": "^11.6.0",
+    "nanoid": "^5.1.5",
+    "next": "^15.3.1",
+    "next-themes": "^0.4.4",
+    "ollama-ai-provider": "^1.2.0",
+    "p-limit": "^6.2.0",
+    "pdfjs-dist": "5.1.91",
+    "radash": "^12.1.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "react-hook-form": "^7.54.2",
+    "react-i18next": "^15.4.1",
+    "react-markdown": "^10.1.0",
+    "react-resizable-panels": "^3.0.1",
+    "react-use-pwa-install": "^1.0.3",
+    "react-zoom-pan-pinch": "^3.7.0",
+    "rehype-highlight": "^7.0.2",
+    "rehype-katex": "^7.0.1",
+    "rehype-raw": "^7.0.0",
+    "remark-breaks": "^4.0.0",
+    "remark-gfm": "^4.0.1",
+    "remark-math": "^6.0.0",
+    "sonner": "^2.0.1",
+    "tailwind-merge": "^3.0.2",
+    "tailwindcss-animate": "^1.0.7",
+    "ts-md5": "^1.3.1",
+    "unist-util-visit": "^5.0.0",
+    "zod": "^3.24.2",
+    "zod-to-json-schema": "^3.24.3",
+    "zustand": "^5.0.3"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3",
+    "@tailwindcss/typography": "^0.5.16",
+    "@types/file-saver": "^2.0.7",
+    "@types/hast": "^3.0.4",
+    "@types/jsdom": "^21.1.7",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "babel-plugin-react-compiler": "19.1.0-rc.1",
+    "cross-env": "^7.0.3",
+    "eslint": "^9",
+    "eslint-config-next": "15.1.7",
+    "ignore-loader": "^0.1.2",
+    "postcss": "^8",
+    "serwist": "^9.0.14",
+    "tailwindcss": "^3.4.1",
+    "typescript": "^5"
+  },
+  "engines": {
+    "npm": ">= 9.8.0",
+    "node": ">= 18.18.0"
+  }
+}

postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    tailwindcss: {},
+  },
+};
+
+export default config;

src/app/api/ai/anthropic/[...slug]/route.ts

@@ -0,0 +1,55 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { ANTHROPIC_BASE_URL } from "@/constants/urls";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL =
+  process.env.ANTHROPIC_API_BASE_URL || ANTHROPIC_BASE_URL;
+
+async function handler(req: NextRequest) {
+  let body;
+  if (req.method.toUpperCase() !== "GET") {
+    body = await req.json();
+  }
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+        "x-api-key": req.headers.get("x-api-key") || "",
+        "anthropic-version":
+          req.headers.get("anthropic-version") || "2023-06-01",
+      },
+    };
+    if (body) payload.body = JSON.stringify(body);
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}
+
+export { handler as GET, handler as POST, handler as PUT, handler as DELETE };

src/app/api/ai/azure/[...slug]/route.ts

@@ -0,0 +1,56 @@
+import { NextResponse, type NextRequest } from "next/server";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL = `https://${process.env.AZURE_RESOURCE_NAME}.openai.azure.com/openai/deployments`;
+const API_VERSION = process.env.AZURE_API_VERSION || "";
+
+async function handler(req: NextRequest) {
+  let body;
+  if (req.method.toUpperCase() !== "GET") {
+    body = await req.json();
+  }
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  if (API_VERSION) searchParams.append("api-version", API_VERSION);
+  const params = searchParams.toString();
+
+  try {
+    if (API_PROXY_BASE_URL === "") {
+      throw new Error("API base url is missing.");
+    }
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+        Authorization: req.headers.get("Authorization") || "",
+      },
+    };
+    if (body) payload.body = JSON.stringify(body);
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}
+
+export { handler as GET, handler as POST, handler as PUT, handler as DELETE };

src/app/api/ai/deepseek/[...slug]/route.ts

@@ -0,0 +1,53 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { DEEPSEEK_BASE_URL } from "@/constants/urls";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL =
+  process.env.DEEPSEEK_API_BASE_URL || DEEPSEEK_BASE_URL;
+
+async function handler(req: NextRequest) {
+  let body;
+  if (req.method.toUpperCase() !== "GET") {
+    body = await req.json();
+  }
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+        Authorization: req.headers.get("Authorization") || "",
+      },
+    };
+    if (body) payload.body = JSON.stringify(body);
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}
+
+export { handler as GET, handler as POST, handler as PUT, handler as DELETE };

src/app/api/ai/google/[...slug]/route.ts

@@ -0,0 +1,57 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { GEMINI_BASE_URL } from "@/constants/urls";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL =
+  process.env.API_PROXY_BASE_URL ||
+  process.env.GOOGLE_GENERATIVE_AI_API_BASE_URL ||
+  GEMINI_BASE_URL;
+
+async function handler(req: NextRequest) {
+  let body;
+  if (req.method.toUpperCase() !== "GET") {
+    body = await req.json();
+  }
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+        "x-goog-api-client":
+          req.headers.get("x-goog-api-client") || "genai-js/0.24.0",
+        "x-goog-api-key": req.headers.get("x-goog-api-key") || "",
+      },
+    };
+    if (body) payload.body = JSON.stringify(body);
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}
+
+export { handler as GET, handler as POST, handler as PUT, handler as DELETE };

src/app/api/ai/mistral/[...slug]/route.ts

@@ -0,0 +1,52 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { MISTRAL_BASE_URL } from "@/constants/urls";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL = process.env.MISTRAL_API_BASE_URL || MISTRAL_BASE_URL;
+
+async function handler(req: NextRequest) {
+  let body;
+  if (req.method.toUpperCase() !== "GET") {
+    body = await req.json();
+  }
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+        Authorization: req.headers.get("Authorization") || "",
+      },
+    };
+    if (body) payload.body = JSON.stringify(body);
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}
+
+export { handler as GET, handler as POST, handler as PUT, handler as DELETE };

src/app/api/ai/ollama/[...slug]/route.ts

@@ -0,0 +1,51 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { OLLAMA_BASE_URL } from "@/constants/urls";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL = process.env.OLLAMA_API_BASE_URL || OLLAMA_BASE_URL;
+
+async function handler(req: NextRequest) {
+  let body;
+  if (req.method.toUpperCase() !== "GET") {
+    body = await req.json();
+  }
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+      },
+    };
+    if (body) payload.body = JSON.stringify(body);
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}
+
+export { handler as GET, handler as POST, handler as PUT, handler as DELETE };

src/app/api/ai/openai/[...slug]/route.ts

@@ -0,0 +1,52 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { OPENAI_BASE_URL } from "@/constants/urls";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL = process.env.OPENAI_API_BASE_URL || OPENAI_BASE_URL;
+
+async function handler(req: NextRequest) {
+  let body;
+  if (req.method.toUpperCase() !== "GET") {
+    body = await req.json();
+  }
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+        Authorization: req.headers.get("Authorization") || "",
+      },
+    };
+    if (body) payload.body = JSON.stringify(body);
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}
+
+export { handler as GET, handler as POST, handler as PUT, handler as DELETE };

src/app/api/ai/openaicompatible/[...slug]/route.ts

@@ -0,0 +1,51 @@
+import { NextResponse, type NextRequest } from "next/server";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL = process.env.OPENAI_COMPATIBLE_API_BASE_URL || "";
+
+async function handler(req: NextRequest) {
+  let body;
+  if (req.method.toUpperCase() !== "GET") {
+    body = await req.json();
+  }
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+        Authorization: req.headers.get("Authorization") || "",
+      },
+    };
+    if (body) payload.body = JSON.stringify(body);
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}
+
+export { handler as GET, handler as POST, handler as PUT, handler as DELETE };

src/app/api/ai/openrouter/[...slug]/route.ts

@@ -0,0 +1,54 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { OPENROUTER_BASE_URL } from "@/constants/urls";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL =
+  process.env.OPENROUTER_API_BASE_URL || OPENROUTER_BASE_URL;
+
+async function handler(req: NextRequest) {
+  let body;
+  if (req.method.toUpperCase() !== "GET") {
+    body = await req.json();
+  }
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/api/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    console.log(url);
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+        Authorization: req.headers.get("Authorization") || "",
+      },
+    };
+    if (body) payload.body = JSON.stringify(body);
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}
+
+export { handler as GET, handler as POST, handler as PUT, handler as DELETE };

src/app/api/ai/pollinations/[...slug]/route.ts

@@ -0,0 +1,52 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { POLLINATIONS_BASE_URL } from "@/constants/urls";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL =
+  process.env.POLLINATIONS_API_BASE_URL || POLLINATIONS_BASE_URL;
+
+async function handler(req: NextRequest) {
+  let body;
+  if (req.method.toUpperCase() !== "GET") {
+    body = await req.json();
+  }
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+      },
+    };
+    if (body) payload.body = JSON.stringify(body);
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}
+
+export { handler as GET, handler as POST, handler as PUT, handler as DELETE };

src/app/api/ai/xai/[...slug]/route.ts

@@ -0,0 +1,52 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { XAI_BASE_URL } from "@/constants/urls";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL = process.env.XAI_API_BASE_URL || XAI_BASE_URL;
+
+async function handler(req: NextRequest) {
+  let body;
+  if (req.method.toUpperCase() !== "GET") {
+    body = await req.json();
+  }
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+        Authorization: req.headers.get("Authorization") || "",
+      },
+    };
+    if (body) payload.body = JSON.stringify(body);
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}
+
+export { handler as GET, handler as POST, handler as PUT, handler as DELETE };

src/app/api/crawler/route.ts

@@ -0,0 +1,36 @@
+import { NextResponse, type NextRequest } from "next/server";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+export async function POST(req: NextRequest) {
+  try {
+    const { url } = await req.json();
+    if (!url) throw new Error("Missing parameters!");
+    const response = await fetch(url, { next: { revalidate: 60 } });
+    const result = await response.text();
+
+    const titleRegex = /<title>(.*?)<\/title>/i;
+    const titleMatch = result.match(titleRegex);
+    const title = titleMatch ? titleMatch[1].trim() : "";
+
+    return NextResponse.json({ url, title, content: result });
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}

src/app/api/mcp/[...slug]/route.ts

@@ -0,0 +1,91 @@
+import { NextRequest, NextResponse } from "next/server";
+import { SSEServerTransport } from "@/libs/mcp-server/sse";
+import { initMcpServer } from "../server";
+
+export const runtime = "edge";
+export const dynamic = "force-dynamic";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+// In-memory storage for active transport sessions.
+// In a production app, consider a more robust distributed cache or state store.
+const activeTransports = new Map<string, SSEServerTransport>();
+
+// The API route path clients will POST messages to
+const POST_ENDPOINT_PATH = "/api/mcp/sse/messages"; // This must match your POST API route path
+
+export async function GET(): Promise<NextResponse> {
+  // Create an MCP server
+  const server = initMcpServer();
+
+  // Create a new transport instance for this session
+  const transport = new SSEServerTransport({
+    endpoint: POST_ENDPOINT_PATH,
+  });
+  const sessionId = transport.sessionId;
+
+  // Store the transport instance keyed by session ID
+  activeTransports.set(sessionId, transport);
+
+  transport.onerror = (error) => {
+    return NextResponse.json(
+      { code: 500, message: error.message },
+      { status: 500 }
+    );
+  };
+
+  transport.onclose = () => {
+    activeTransports.delete(sessionId); // Clean up the instance
+    transport.close();
+    server.close();
+  };
+
+  await server.connect(transport);
+  // Call the transport method to handle the GET request and return the SSE response
+  const response = await transport.handleGetRequest();
+  return new NextResponse(response.body, response);
+}
+
+export async function POST(req: NextRequest): Promise<NextResponse> {
+  // Extract the session ID from the query parameter sent by the client
+  const sessionId = req.nextUrl.searchParams.get("sessionId");
+
+  if (!sessionId) {
+    return new NextResponse(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        error: { code: -32600, message: "Missing sessionId query parameter" },
+        id: null,
+      }),
+      { status: 400, headers: { "Content-Type": "application/json" } }
+    );
+  }
+
+  // Find the corresponding transport instance
+  const transport = activeTransports.get(sessionId);
+
+  if (!transport) {
+    // Session not found or already closed
+    console.warn(`Received POST for unknown session ID: ${sessionId}`);
+    return new NextResponse(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        error: { code: -32001, message: "Session not found" },
+        id: null,
+      }),
+      { status: 404, headers: { "Content-Type": "application/json" } }
+    );
+  }
+
+  // Delegate the POST message handling to the specific transport instance
+  const response = await transport.handlePostMessage(req);
+  return new NextResponse(response.body, response);
+}

src/app/api/mcp/route.ts

@@ -0,0 +1,50 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { StreamableHTTPServerTransport } from "@/libs/mcp-server/streamableHttp";
+import { initMcpServer } from "./server";
+
+export const runtime = "edge";
+export const dynamic = "force-dynamic";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+export async function POST(req: NextRequest) {
+  try {
+    const server = initMcpServer();
+    const transport: StreamableHTTPServerTransport =
+      new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+      });
+
+    transport.onclose = () => {
+      transport.close();
+      server.close();
+    };
+
+    transport.onerror = (err) => {
+      return NextResponse.json(
+        { code: 500, message: err.message },
+        { status: 500 }
+      );
+    };
+
+    await server.connect(transport);
+    const response = await transport.handleRequest(req);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}

src/app/api/mcp/server.ts

@@ -0,0 +1,404 @@
+import { z } from "zod";
+import { McpServer } from "@/libs/mcp-server/mcp";
+import DeepResearch from "@/utils/deep-research";
+import { multiApiKeyPolling } from "@/utils/model";
+import {
+  getAIProviderBaseURL,
+  getAIProviderApiKey,
+  getSearchProviderBaseURL,
+  getSearchProviderApiKey,
+} from "../utils";
+
+const AI_PROVIDER = process.env.MCP_AI_PROVIDER || "";
+const SEARCH_PROVIDER = process.env.MCP_SEARCH_PROVIDER || "model";
+const THINKING_MODEL = process.env.MCP_THINKING_MODEL || "";
+const TASK_MODEL = process.env.MCP_TASK_MODEL || "";
+
+function initDeepResearchServer({
+  language,
+  maxResult,
+}: {
+  language?: string;
+  maxResult?: number;
+}) {
+  const deepResearch = new DeepResearch({
+    language,
+    AIProvider: {
+      baseURL: getAIProviderBaseURL(AI_PROVIDER),
+      apiKey: multiApiKeyPolling(getAIProviderApiKey(AI_PROVIDER)),
+      provider: AI_PROVIDER,
+      thinkingModel: THINKING_MODEL,
+      taskModel: TASK_MODEL,
+    },
+    searchProvider: {
+      baseURL: getSearchProviderBaseURL(SEARCH_PROVIDER),
+      apiKey: multiApiKeyPolling(getSearchProviderApiKey(SEARCH_PROVIDER)),
+      provider: SEARCH_PROVIDER,
+      maxResult,
+    },
+    onMessage: (event, data) => {
+      if (event === "progress") {
+        console.log(
+          `[${data.step}]: ${data.name ? `"${data.name}" ` : ""}${data.status}`
+        );
+        if (data.status === "end" && data.data) {
+          console.log(data.data);
+        }
+      } else if (event === "error") {
+        console.error(data.message);
+        throw new Error(data.message);
+      }
+    },
+  });
+
+  return deepResearch;
+}
+
+export function initMcpServer() {
+  const deepResearchToolDescription =
+    "Start deep research on any question, obtain and organize information through search engines, and generate research report.";
+  const writeResearchPlanDescription =
+    "Generate research plan based on user query.";
+  const generateSERPQueryDescription =
+    "Generate a list of data collection tasks based on the research plan.";
+  const searchTaskDescription =
+    "Generate SERP queries based on the research plan.";
+  const writeFinalReportDescription =
+    "Write a final research report based on the research plan and the results of the information collection tasks.";
+
+  const server = new McpServer(
+    {
+      name: "deep-research",
+      version: "0.1.0",
+    },
+    {
+      capabilities: {
+        tools: {
+          "deep-research": {
+            description: deepResearchToolDescription,
+          },
+          "write-research-plan": {
+            description: writeResearchPlanDescription,
+          },
+          "generate-SERP-query": {
+            description: generateSERPQueryDescription,
+          },
+          "search-task": {
+            description: searchTaskDescription,
+          },
+          "write-final-report": {
+            description: writeFinalReportDescription,
+          },
+        },
+      },
+    }
+  );
+
+  server.tool(
+    "deep-research",
+    deepResearchToolDescription,
+    {
+      query: z.string().describe("The topic for deep research."),
+      language: z
+        .string()
+        .optional()
+        .describe("The final report text language."),
+      maxResult: z
+        .number()
+        .optional()
+        .default(5)
+        .describe("Maximum number of search results."),
+      enableCitationImage: z
+        .boolean()
+        .default(true)
+        .optional()
+        .describe(
+          "Whether to include content-related images in the final report."
+        ),
+      enableReferences: z
+        .boolean()
+        .default(true)
+        .optional()
+        .describe(
+          "Whether to include citation links in search results and final reports."
+        ),
+    },
+    async (
+      { query, language, maxResult, enableCitationImage, enableReferences },
+      { signal }
+    ) => {
+      signal.addEventListener("abort", () => {
+        throw new Error("The client closed unexpectedly!");
+      });
+
+      try {
+        const deepResearch = initDeepResearchServer({
+          language,
+          maxResult,
+        });
+        const result = await deepResearch.start(
+          query,
+          enableCitationImage,
+          enableReferences
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${
+                error instanceof Error ? error.message : "Unknown error"
+              }`,
+            },
+          ],
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "write-research-plan",
+    writeResearchPlanDescription,
+    {
+      query: z.string().describe("The topic for deep research."),
+      language: z.string().optional().describe("The response Language."),
+    },
+    async ({ query, language }, { signal }) => {
+      signal.addEventListener("abort", () => {
+        throw new Error("The client closed unexpectedly!");
+      });
+
+      try {
+        const deepResearch = initDeepResearchServer({ language });
+        const result = await deepResearch.writeReportPlan(query);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify({ reportPlan: result }) },
+          ],
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${
+                error instanceof Error ? error.message : "Unknown error"
+              }`,
+            },
+          ],
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "generate-SERP-query",
+    generateSERPQueryDescription,
+    {
+      plan: z.string().describe("Research plan for deep research."),
+      language: z.string().optional().describe("The response Language."),
+    },
+    async ({ plan, language }, { signal }) => {
+      signal.addEventListener("abort", () => {
+        throw new Error("The client closed unexpectedly!");
+      });
+
+      try {
+        const deepResearch = initDeepResearchServer({ language });
+        const result = await deepResearch.generateSERPQuery(plan);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${
+                error instanceof Error ? error.message : "Unknown error"
+              }`,
+            },
+          ],
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "search-task",
+    searchTaskDescription,
+    {
+      tasks: z
+        .array(
+          z.object({
+            query: z.string().describe("Information to be queried."),
+            researchGoal: z.string().describe("The goal of this query task."),
+          })
+        )
+        .describe("Information Collection Task List."),
+      language: z.string().optional().describe("The response Language."),
+      maxResult: z
+        .number()
+        .optional()
+        .default(5)
+        .describe("Maximum number of search results."),
+      enableReferences: z
+        .boolean()
+        .default(true)
+        .optional()
+        .describe(
+          "Whether to include citation links in search results and final reports."
+        ),
+    },
+    async (
+      { tasks, language, maxResult, enableReferences = true },
+      { signal }
+    ) => {
+      signal.addEventListener("abort", () => {
+        throw new Error("The client closed unexpectedly!");
+      });
+
+      try {
+        const deepResearch = initDeepResearchServer({ language, maxResult });
+        const result = await deepResearch.runSearchTask(
+          tasks,
+          enableReferences
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${
+                error instanceof Error ? error.message : "Unknown error"
+              }`,
+            },
+          ],
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "write-final-report",
+    writeFinalReportDescription,
+    {
+      plan: z.string().describe("Research plan for deep research."),
+      tasks: z
+        .array(
+          z.object({
+            query: z.string().describe("Information to be queried."),
+            researchGoal: z.string().describe("The goal of this query task."),
+            learning: z
+              .string()
+              .describe(
+                "Knowledge learned while performing information gathering tasks."
+              ),
+            sources: z
+              .array(
+                z.object({
+                  url: z.string().describe("Web link."),
+                  title: z.string().optional().describe("Page title."),
+                })
+              )
+              .optional()
+              .describe(
+                "Web page information that was queried when performing information collection tasks."
+              ),
+            images: z
+              .array(
+                z.object({
+                  url: z.string().describe("Image link."),
+                  description: z
+                    .string()
+                    .optional()
+                    .describe("Image Description."),
+                })
+              )
+              .optional()
+              .describe(
+                "Image resources obtained when performing information collection tasks."
+              ),
+          })
+        )
+        .describe(
+          "The data information collected during the execution of the query task."
+        ),
+      language: z
+        .string()
+        .optional()
+        .describe("The final report text language."),
+      maxResult: z
+        .number()
+        .optional()
+        .default(5)
+        .describe("Maximum number of search results."),
+      enableCitationImage: z
+        .boolean()
+        .default(true)
+        .optional()
+        .describe(
+          "Whether to include content-related images in the final report."
+        ),
+      enableReferences: z
+        .boolean()
+        .default(true)
+        .optional()
+        .describe(
+          "Whether to include citation links in search results and final reports."
+        ),
+    },
+    async (
+      {
+        plan,
+        tasks,
+        language,
+        maxResult,
+        enableCitationImage = true,
+        enableReferences = true,
+      },
+      { signal }
+    ) => {
+      signal.addEventListener("abort", () => {
+        throw new Error("The client closed unexpectedly!");
+      });
+
+      try {
+        const deepResearch = initDeepResearchServer({ language, maxResult });
+        const result = await deepResearch.writeFinalReport(
+          plan,
+          tasks,
+          enableCitationImage,
+          enableReferences
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+        };
+      } catch (error) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Error: ${
+                error instanceof Error ? error.message : "Unknown error"
+              }`,
+            },
+          ],
+        };
+      }
+    }
+  );
+
+  return server;
+}

src/app/api/search/bocha/[...slug]/route.ts

@@ -0,0 +1,47 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { BOCHA_BASE_URL } from "@/constants/urls";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL = process.env.BOCHA_API_BASE_URL || BOCHA_BASE_URL;
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+        Authorization: req.headers.get("Authorization") || "",
+      },
+      body: JSON.stringify(body),
+    };
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}

src/app/api/search/exa/[...slug]/route.ts

@@ -0,0 +1,47 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { EXA_BASE_URL } from "@/constants/urls";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL = process.env.EXA_API_BASE_URL || EXA_BASE_URL;
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+        Authorization: req.headers.get("Authorization") || "",
+      },
+      body: JSON.stringify(body),
+    };
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}

src/app/api/search/firecrawl/[...slug]/route.ts

@@ -0,0 +1,48 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { FIRECRAWL_BASE_URL } from "@/constants/urls";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL =
+  process.env.FIRECRAWL_API_BASE_URL || FIRECRAWL_BASE_URL;
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+        Authorization: req.headers.get("Authorization") || "",
+      },
+      body: JSON.stringify(body),
+    };
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}

src/app/api/search/searxng/[...slug]/route.ts

@@ -0,0 +1,49 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { SEARXNG_BASE_URL } from "@/constants/urls";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL = process.env.SEARXNG_API_BASE_URL || SEARXNG_BASE_URL;
+
+export async function POST(req: NextRequest) {
+  let body;
+  if (req.method.toUpperCase() !== "GET") {
+    body = await req.json();
+  }
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+      },
+    };
+    if (body) payload.body = JSON.stringify(body);
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}

src/app/api/search/tavily/[...slug]/route.ts

@@ -0,0 +1,47 @@
+import { NextResponse, type NextRequest } from "next/server";
+import { TAVILY_BASE_URL } from "@/constants/urls";
+
+export const runtime = "edge";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+const API_PROXY_BASE_URL = process.env.TAVILY_API_BASE_URL || TAVILY_BASE_URL;
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const searchParams = req.nextUrl.searchParams;
+  const path = searchParams.getAll("slug");
+  searchParams.delete("slug");
+  const params = searchParams.toString();
+
+  try {
+    let url = `${API_PROXY_BASE_URL}/${decodeURIComponent(path.join("/"))}`;
+    if (params) url += `?${params}`;
+    const payload: RequestInit = {
+      method: req.method,
+      headers: {
+        "Content-Type": req.headers.get("Content-Type") || "application/json",
+        Authorization: req.headers.get("Authorization") || "",
+      },
+      body: JSON.stringify(body),
+    };
+    const response = await fetch(url, payload);
+    return new NextResponse(response.body, response);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(error);
+      return NextResponse.json(
+        { code: 500, message: error.message },
+        { status: 500 }
+      );
+    }
+  }
+}

src/app/api/sse/live/route.ts

@@ -0,0 +1,105 @@
+import { NextResponse, type NextRequest } from "next/server";
+import DeepResearch from "@/utils/deep-research";
+import { multiApiKeyPolling } from "@/utils/model";
+import {
+  getAIProviderBaseURL,
+  getAIProviderApiKey,
+  getSearchProviderBaseURL,
+  getSearchProviderApiKey,
+} from "../../utils";
+
+export const runtime = "edge";
+export const dynamic = "force-dynamic";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+export async function GET(req: NextRequest) {
+  function getValueFromSearchParams(key: string) {
+    return req.nextUrl.searchParams.get(key);
+  }
+  const query = getValueFromSearchParams("query") || "";
+  const provider = getValueFromSearchParams("provider") || "";
+  const thinkingModel = getValueFromSearchParams("thinkingModel") || "";
+  const taskModel = getValueFromSearchParams("taskModel") || "";
+  const searchProvider = getValueFromSearchParams("searchProvider") || "";
+  const language = getValueFromSearchParams("language") || "";
+  const maxResult = Number(getValueFromSearchParams("maxResult")) || 5;
+  const enableCitationImage =
+    getValueFromSearchParams("enableCitationImage") === "false";
+  const enableReferences =
+    getValueFromSearchParams("enableReferences") === "false";
+
+  const encoder = new TextEncoder();
+  const readableStream = new ReadableStream({
+    start: async (controller) => {
+      console.log("Client connected");
+
+      req.signal.addEventListener("abort", () => {
+        console.log("Client disconnected");
+      });
+
+      const deepResearch = new DeepResearch({
+        language,
+        AIProvider: {
+          baseURL: getAIProviderBaseURL(provider),
+          apiKey: multiApiKeyPolling(getAIProviderApiKey(provider)),
+          provider,
+          thinkingModel,
+          taskModel,
+        },
+        searchProvider: {
+          baseURL: getSearchProviderBaseURL(searchProvider),
+          apiKey: multiApiKeyPolling(getSearchProviderApiKey(searchProvider)),
+          provider: searchProvider,
+          maxResult,
+        },
+        onMessage: (event, data) => {
+          if (event === "message") {
+            controller.enqueue(encoder.encode(data.text));
+          } else if (event === "progress") {
+            console.log(
+              `[${data.step}]: ${data.name ? `"${data.name}" ` : ""}${
+                data.status
+              }`
+            );
+            if (data.step === "final-report" && data.status === "end") {
+              controller.close();
+            }
+          } else if (event === "error") {
+            console.error(data);
+            controller.close();
+          }
+        },
+      });
+
+      req.signal.addEventListener("abort", () => {
+        controller.close();
+      });
+
+      try {
+        await deepResearch.start(query, enableCitationImage, enableReferences);
+      } catch (err) {
+        throw new Error(err instanceof Error ? err.message : "Unknown error");
+      }
+      controller.close();
+    },
+  });
+
+  return new NextResponse(readableStream, {
+    headers: {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+      "Access-Control-Allow-Origin": "*",
+    },
+  });
+}

src/app/api/sse/route.ts

@@ -0,0 +1,111 @@
+import { NextResponse, type NextRequest } from "next/server";
+import DeepResearch from "@/utils/deep-research";
+import { multiApiKeyPolling } from "@/utils/model";
+import {
+  getAIProviderBaseURL,
+  getAIProviderApiKey,
+  getSearchProviderBaseURL,
+  getSearchProviderApiKey,
+} from "../utils";
+
+export const runtime = "edge";
+export const dynamic = "force-dynamic";
+export const preferredRegion = [
+  "cle1",
+  "iad1",
+  "pdx1",
+  "sfo1",
+  "sin1",
+  "syd1",
+  "hnd1",
+  "kix1",
+];
+
+export async function POST(req: NextRequest) {
+  const {
+    query,
+    provider,
+    thinkingModel,
+    taskModel,
+    searchProvider,
+    language,
+    maxResult,
+    enableCitationImage = true,
+    enableReferences = true,
+  } = await req.json();
+
+  const encoder = new TextEncoder();
+  const readableStream = new ReadableStream({
+    start: async (controller) => {
+      console.log("Client connected");
+      controller.enqueue(
+        encoder.encode(
+          `event: infor\ndata: ${JSON.stringify({
+            name: "deep-research",
+            version: "0.1.0",
+          })}\n\n`
+        )
+      );
+
+      const deepResearch = new DeepResearch({
+        language,
+        AIProvider: {
+          baseURL: getAIProviderBaseURL(provider),
+          apiKey: multiApiKeyPolling(getAIProviderApiKey(provider)),
+          provider,
+          thinkingModel,
+          taskModel,
+        },
+        searchProvider: {
+          baseURL: getSearchProviderBaseURL(searchProvider),
+          apiKey: multiApiKeyPolling(getSearchProviderApiKey(searchProvider)),
+          provider: searchProvider,
+          maxResult,
+        },
+        onMessage: (event, data) => {
+          if (event === "progress") {
+            console.log(
+              `[${data.step}]: ${data.name ? `"${data.name}" ` : ""}${
+                data.status
+              }`
+            );
+            if (data.step === "final-report" && data.status === "end") {
+              controller.close();
+            }
+          } else if (event === "error") {
+            console.error(data);
+            controller.close();
+          } else {
+            console.warn(`Unknown event: ${event}`);
+          }
+          controller.enqueue(
+            encoder.encode(
+              `event: ${event}\ndata: ${JSON.stringify(data)})}\n\n`
+            )
+          );
+        },
+      });
+
+      req.signal.addEventListener("abort", () => {
+        controller.close();
+      });
+
+      try {
+        await deepResearch.start(query, enableCitationImage, enableReferences);
+      } catch (err) {
+        throw new Error(err instanceof Error ? err.message : "Unknown error");
+      }
+      controller.close();
+    },
+  });
+
+  return new NextResponse(readableStream, {
+    headers: {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+      "Access-Control-Allow-Origin": "*",
+    },
+  });
+}