chore(release): bump version to 0.1.14

2026-07-16 11:04:26 -04:00 · 2025-04-18 10:43:59 +00:00
707 changed files with 24982 additions and 44179 deletions
@@ -0,0 +1,5 @@
+---
+"create-llama": patch
+---
+
+chore: test typescript e2e with node 20 and 22
@@ -0,0 +1,12 @@
+{
+  "extends": [
+    "prettier"
+  ],
+  "rules": {
+    "max-params": [
+      "error",
+      4
+    ],
+    "prefer-const": "error",
+  },
+}
@@ -1,15 +1,16 @@
-name: E2E Tests for create-llama package
+name: E2E Tests
 on:
  push:
    branches: [main]
    paths-ignore:
-      - "python/llama-index-server/**"
-      - ".github/workflows/*llama_index_server.yml"
+      - "llama-index-server/**"
  pull_request:
    branches: [main]
    paths-ignore:
-      - "python/llama-index-server/**"
-      - ".github/workflows/*llama_index_server.yml"
+      - "llama-index-server/**"
+
+env:
+  POETRY_VERSION: "1.6.1"

 jobs:
  e2e-python:
@@ -22,7 +23,7 @@ jobs:
        python-version: ["3.11"]
        os: [macos-latest, windows-latest, ubuntu-22.04]
        frameworks: ["fastapi"]
-        vectordbs: ["none", "llamacloud"]
+        datasources: ["--no-files", "--example-file", "--llamacloud"]
    defaults:
      run:
        shell: bash
@@ -35,10 +36,10 @@ jobs:
        with:
          python-version: ${{ matrix.python-version }}

-      - name: Install uv
-        run: curl -LsSf https://astral.sh/uv/install.sh | sh
-      - name: Add uv to PATH # Ensure uv is available in subsequent steps
-        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+      - name: Install Poetry
+        uses: snok/install-poetry@v1
+        with:
+          version: ${{ env.POETRY_VERSION }}

      - uses: pnpm/action-setup@v3

@@ -53,24 +54,15 @@ jobs:

      - name: Install Playwright Browsers
        run: pnpm exec playwright install --with-deps
-        working-directory: packages/create-llama
+        working-directory: .

      - name: Build create-llama
        run: pnpm run build
-        working-directory: packages/create-llama
+        working-directory: .

      - name: Install
        run: pnpm run pack-install
-        working-directory: packages/create-llama
-
-      - name: Build and store server package
-        run: |
-          pnpm run build
-          wheel_file=$(ls dist/*.whl | head -n 1)
-          mkdir -p "${{ runner.temp }}"
-          cp "$wheel_file" "${{ runner.temp }}/"
-          echo "SERVER_PACKAGE_PATH=${{ runner.temp }}/$(basename "$wheel_file")" >> $GITHUB_ENV
-        working-directory: python/llama-index-server
+        working-directory: .

      - name: Run Playwright tests for Python
        run: pnpm run e2e:python
@@ -78,17 +70,16 @@ jobs:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          LLAMA_CLOUD_API_KEY: ${{ secrets.LLAMA_CLOUD_API_KEY }}
          FRAMEWORK: ${{ matrix.frameworks }}
-          VECTORDB: ${{ matrix.vectordbs }}
+          DATASOURCE: ${{ matrix.datasources }}
          PYTHONIOENCODING: utf-8
          PYTHONLEGACYWINDOWSSTDIO: utf-8
-          SERVER_PACKAGE_PATH: ${{ env.SERVER_PACKAGE_PATH }}
-        working-directory: packages/create-llama
+        working-directory: .

      - uses: actions/upload-artifact@v4
        if: always()
        with:
-          name: playwright-report-python-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.vectordbs }}
-          path: packages/create-llama/playwright-report/
+          name: playwright-report-python-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.datasources }}
+          path: ./playwright-report/
          overwrite: true
          retention-days: 30

@@ -98,10 +89,11 @@ jobs:
    strategy:
      fail-fast: true
      matrix:
-        node-version: [22]
+        node-version: [20, 22]
+        python-version: ["3.11"]
        os: [macos-latest, windows-latest, ubuntu-22.04]
        frameworks: ["nextjs"]
-        vectordbs: ["none", "llamacloud"]
+        datasources: ["--no-files", "--example-file", "--llamacloud"]
    defaults:
      run:
        shell: bash
@@ -109,6 +101,16 @@ jobs:
    steps:
      - uses: actions/checkout@v4

+      - name: Set up python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Poetry
+        uses: snok/install-poetry@v1
+        with:
+          version: ${{ env.POETRY_VERSION }}
+
      - uses: pnpm/action-setup@v3

      - name: Setup Node.js ${{ matrix.node-version }}
@@ -122,46 +124,29 @@ jobs:

      - name: Install Playwright Browsers
        run: pnpm exec playwright install --with-deps
-        working-directory: packages/create-llama
+        working-directory: .

      - name: Build create-llama
        run: pnpm run build
-        working-directory: packages/create-llama
+        working-directory: .

      - name: Install
        run: pnpm run pack-install
-        working-directory: packages/create-llama
-
-      - name: Build server
-        run: pnpm run build
-        working-directory: packages/server
-
-      - name: Pack @llamaindex/server package
-        run: |
-          pnpm pack --pack-destination "${{ runner.temp }}"
-          if [ "${{ runner.os }}" == "Windows" ]; then
-            file=$(find "${{ runner.temp }}" -name "llamaindex-server-*.tgz" | head -n 1)
-            mv "$file" "${{ runner.temp }}/llamaindex-server.tgz"
-          else
-            mv ${{ runner.temp }}/llamaindex-server-*.tgz ${{ runner.temp }}/llamaindex-server.tgz
-          fi
-        working-directory: packages/server
+        working-directory: .

      - name: Run Playwright tests for TypeScript
-        run: |
-          pnpm run e2e:ts
+        run: pnpm run e2e:typescript
        env:
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          LLAMA_CLOUD_API_KEY: ${{ secrets.LLAMA_CLOUD_API_KEY }}
          FRAMEWORK: ${{ matrix.frameworks }}
-          VECTORDB: ${{ matrix.vectordbs }}
-          SERVER_PACKAGE_PATH: ${{ runner.temp }}/llamaindex-server.tgz
-        working-directory: packages/create-llama
+          DATASOURCE: ${{ matrix.datasources }}
+        working-directory: .

      - uses: actions/upload-artifact@v4
        if: always()
        with:
-          name: playwright-report-typescript-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.vectordbs}}-node${{ matrix.node-version }}
-          path: packages/create-llama/playwright-report/
+          name: playwright-report-typescript-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.datasources }}-node${{ matrix.node-version }}
+          path: ./playwright-report/
          overwrite: true
          retention-days: 30
@@ -16,16 +16,6 @@ jobs:

      - uses: pnpm/action-setup@v3

-      - name: Setup Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
@@ -41,21 +31,12 @@ jobs:
      - name: Run Prettier
        run: pnpm run format

-      - name: Run build
-        run: pnpm run build
-
-      - name: Run Typecheck for examples
-        run: pnpm run typecheck
-        working-directory: packages/server/examples
-
      - name: Run Python format check
        uses: chartboost/ruff-action@v1
        with:
          args: "format --check"
-          src: "python/llama-index-server"

      - name: Run Python lint
        uses: chartboost/ruff-action@v1
        with:
          args: "check"
-          src: "python/llama-index-server"
@@ -17,11 +17,6 @@ jobs:

      - uses: pnpm/action-setup@v3

-      - name: Setup Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
      - name: Install uv
        uses: astral-sh/setup-uv@v3

@@ -56,12 +51,8 @@ jobs:
        with:
          commit: Release ${{ steps.get-changeset-status.outputs.new-version }}
          title: Release ${{ steps.get-changeset-status.outputs.new-version }}
-          # bump versions
-          version: pnpm new-version
          # build package and call changeset publish
          publish: pnpm release
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-          PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}
-          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}
@@ -0,0 +1,130 @@
+name: Release llama-index-server
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - "llama-index-server/**"
+      - ".github/workflows/release_llama_index_server.yml"
+  pull_request:
+    types:
+      - closed
+
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+
+jobs:
+  release:
+    name: Create Release PR
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./llama-index-server
+    if: |
+      github.event_name == 'push' && 
+      !startsWith(github.ref, 'refs/heads/release/llama-index-server-v')
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install Poetry
+        run: |
+          curl -sSL https://install.python-poetry.org | python3 -
+
+      - name: Install dependencies
+        run: poetry install
+
+      - name: Setup Git
+        run: |
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+          git config --global user.name "github-actions[bot]"
+
+      - name: Bump patch version
+        run: |
+          poetry version patch
+          git add pyproject.toml
+          git commit -m "chore(release): bump version to $(poetry version -s)"
+
+      - name: Get current version
+        id: get_version
+        run: |
+          version=$(poetry version -s)
+          echo "current_version=${version}" >> "$GITHUB_OUTPUT"
+
+      - name: Create Release PR
+        uses: peter-evans/create-pull-request@v6
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          commit-message: "Release: llama-index-server v${{ steps.get_version.outputs.current_version }}"
+          title: "Release: llama-index-server v${{ steps.get_version.outputs.current_version }}"
+          body: |
+            This PR was automatically created to release a new version of the llama-index-server package.
+
+            Version: ${{ steps.get_version.outputs.current_version }}
+
+            Please review the changes and merge to trigger the release.
+          branch: release/llama-index-server-v${{ steps.get_version.outputs.current_version }}
+          base: main
+          labels: release, llama-index-server
+
+  publish:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./llama-index-server
+    if: |
+      github.event_name == 'pull_request' && 
+      github.event.pull_request.merged == true && 
+      startsWith(github.event.pull_request.title, 'Release: llama-index-server') &&
+      startsWith(github.event.pull_request.head.ref, 'release/llama-index-server-v')
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install Poetry
+        run: |
+          curl -sSL https://install.python-poetry.org | python3 -
+
+      - name: Install dependencies
+        run: poetry install
+
+      - name: Get current version
+        id: get_version
+        run: |
+          version=$(poetry version -s)
+          echo "current_version=${version}" >> "$GITHUB_OUTPUT"
+
+      - name: Build and publish to PyPI
+        uses: JRubics/poetry-publish@v2.1
+        with:
+          python_version: "3.11"
+          pypi_token: ${{ secrets.PYPI_TOKEN }}
+          package_directory: "llama-index-server"
+          poetry_install_options: "--without dev"
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: llama-index-server-v${{ steps.get_version.outputs.current_version }}
+          name: "llama-index-server v${{ steps.get_version.outputs.current_version }}"
+          body: |
+            Release of llama-index-server v${{ steps.get_version.outputs.current_version }}
+          draft: false
+          prerelease: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -4,8 +4,8 @@ on:
  pull_request:

 env:
+  POETRY_VERSION: "1.8.3"
  PYTHON_VERSION: "3.9"
-  UI_TEST: "true"

 jobs:
  unit-test:
@@ -13,124 +13,99 @@ jobs:
    runs-on: ${{ matrix.os }}
    defaults:
      run:
-        working-directory: python/llama-index-server
+        working-directory: llama-index-server
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest]
        python-version: ["3.9"]
    steps:
      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v3

-      - name: Setup Python
+      - name: Install Poetry
+        run: pipx install poetry==${{ env.POETRY_VERSION }}
+
+      - name: Set up python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
+          cache: "poetry"

-      - name: Install uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: ".nvmrc"
-          cache: "pnpm"
+      - name: Configure Poetry
+        run: |
+          poetry config virtualenvs.create true
+          poetry config virtualenvs.in-project true
+          poetry env use python

      - name: Install dependencies
        shell: bash
-        run: pnpm install && pnpm build
+        run: poetry install --with dev

      - name: Run unit tests
        shell: bash
-        run: uv run pytest tests
+        run: |
+          poetry run pytest tests

  type-check:
    name: Type Check
    runs-on: ubuntu-latest
    defaults:
      run:
-        working-directory: python/llama-index-server
+        working-directory: llama-index-server
    steps:
      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v3

-      - name: Setup Python
+      - name: Install Poetry
+        run: pipx install poetry==${{ env.POETRY_VERSION }}
+
+      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: ${{ env.PYTHON_VERSION }}
+          cache: "poetry"

-      - name: Install uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
+      - name: Configure Poetry
+        run: |
+          poetry config virtualenvs.create true
+          poetry config virtualenvs.in-project true
+          poetry env use python

      - name: Install dependencies
-        run: pnpm install
+        shell: bash
+        run: poetry install --with dev

      - name: Run mypy
        shell: bash
-        run: uv run mypy llama_index
+        run: poetry run mypy llama_index

  build:
    needs: [unit-test, type-check]
    runs-on: ubuntu-latest
    defaults:
      run:
-        working-directory: python/llama-index-server
+        working-directory: llama-index-server
    steps:
      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v3
-
+      - name: Install Poetry
+        run: pipx install poetry==${{ env.POETRY_VERSION }}
      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: ${{ env.PYTHON_VERSION }}
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v5
-        with:
-          enable-cache: true
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: ".nvmrc"
-          cache: "pnpm"
-
-      - name: Install dependencies
-        run: pnpm install && pnpm build
-
+      - name: Clear python cache
+        shell: bash
+        run: poetry cache clear --all pypi
      - name: Build package
        shell: bash
-        run: uv build
-
-      - name: Get the absolute wheel file path and save it to the output
+        run: poetry build
+      - name: Test installing built package
        shell: bash
-        id: get_whl_path
-        run: |
-          WHL_FILE=$(readlink -f dist/*.whl)
-          echo "whl_file=$WHL_FILE" >> $GITHUB_OUTPUT
-
+        run: python -m pip install .
      - name: Test import
        shell: bash
-        working-directory: ${{ github.workspace }}
-        env:
-          WHL_FILE: ${{ steps.get_whl_path.outputs.whl_file }}
-        run: |
-          uv run --with $WHL_FILE python -c "from llama_index.server import LlamaIndexServer"
-
-      - name: Check frontend resources is present
-        shell: bash
-        working-directory: ${{ github.workspace }}
-        env:
-          WHL_FILE: ${{ steps.get_whl_path.outputs.whl_file }}
-        run: |
-          uv run --with $WHL_FILE python -c "from llama_index.server.chat_ui import check_ui_resources; check_ui_resources()"
-
+        working-directory: ${{ vars.RUNNER_TEMP }}
+        run: python -c "from llama_index.server import LlamaIndexServer"
      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: llama-index-server
-          path: dist/
+          path: llama-index-server/dist/
@@ -6,6 +6,10 @@ node_modules
 .pnpm-store
 .pnp.js

+# testing
+coverage
+.coverage
+
 # next.js
 .next/
 out/
@@ -31,9 +35,31 @@ yarn-error.log*
 dist/
 lib/

+# e2e
+.cache
+test-results/
+playwright-report/
+blob-report/
+playwright/.cache/
+.tsbuildinfo
+e2e/cache
+
 # intellij
 **/.idea

+# Python
+.mypy_cache/
+venv/
+.venv/
+dist/
+.__pycache__
+__pycache__
+.python-version
+.ui
+
+# build artifacts
+create-llama-*.tgz
+
 # vscode
 .vscode
 !.vscode/settings.json
@@ -1,4 +1,3 @@
 pnpm format
 pnpm lint
-uvx ruff check .
-uvx ruff format . --check 
+uvx ruff format --check templates/
@@ -1,18 +1,6 @@
-node_modules/
+apps/docs/i18n
+apps/docs/docs/api
 pnpm-lock.yaml
 lib/
 dist/
-cache/
-build/
-.next/
-out/
-packages/server/server/
-packages/server/project/
-**/playwright-report/
-**/test-results/
-
-# Python
-python/
-**/*.mypy_cache/**
-**/*.venv/**
-**/*.ruff_cache/**
+.docusaurus/
@@ -1,123 +1,5 @@
 # create-llama

-## 0.6.1
-
-### Patch Changes
-
- 952b5b4: fix: peer deps and sourcemap issues made ts server start fail
- e8004fd: Fix: broken devcontainer due to deleted repo
-
-## 0.6.0
-
-### Minor Changes
-
- 8fa8c3b: Removed deprecated templates and simplified code
-
-### Patch Changes
-
- 8fa8c3b: Feat: re-add --ask-models
-
-## 0.5.22
-
-### Patch Changes
-
- e2486eb: feat: support human in the loop for TS
-
-## 0.5.21
-
-### Patch Changes
-
- af9ad3c: feat: show document artifact after generating report
- a543a27: feat: bump chat-ui with inline artifact
-
-## 0.5.20
-
-### Patch Changes
-
- 3ff0a18: fix: default header padding
-
-## 0.5.19
-
-### Patch Changes
-
- 5fe9e17: support eject to fully customize next folder
- b8a1ff6: Support citation for agentic template (Python)
-
-## 0.5.18
-
-### Patch Changes
-
- 8d59ef0: Add layout_dir config to the generated python code
-
-## 0.5.17
-
-### Patch Changes
-
- eee3230: feat: support custom layout
-
-## 0.5.16
-
-### Patch Changes
-
- 6f75d4a: fix: unsupported language in code gen workflow
- d0618fa: Fix LlamaCloud generate script issue
-
-## 0.5.15
-
-### Patch Changes
-
- 527075c: Enable dev mode that allows updating code directly in the UI
-
-## 0.5.14
-
-### Patch Changes
-
- 1df8cfb: Split artifacts use case to document generator and code generator
- 1b5a519: chore: improve dev experience with nodemon
- b3eb0ba: Fix typing check issue
- 556f33c: fix chromadb dependency issue
- 2451539: fix: remove dead generated ai code
- 7a70390: Deprecate pro mode
-
-## 0.5.13
-
-### Patch Changes
-
- f4ca602: Add artifact use case for Typescript template
- f4ca602: Update typescript use cases to use the new workflow engine
-
-## 0.5.12
-
-### Patch Changes
-
- 241d82a: Add artifacts use case (python)
-
-## 0.5.11
-
-### Patch Changes
-
- 3960618: chore: create-llama monorepo
- 8fe5fc2: chore: add llamaindex server package
-
-## 0.5.10
-
-### Patch Changes
-
- 0a2e12a: Use uv as the default package manager
-
-## 0.5.9
-
-### Patch Changes
-
- 4bc53ac: Bump new chat ui and update deep research component
- 4bc53ac: Support generate UI for deep research use case (Typescript)
-
-## 0.5.8
-
-### Patch Changes
-
- 765181a: chore: test typescript e2e with node 20 and 22
-
 ## 0.5.7

 ### Patch Changes
@@ -1,201 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Repository Overview
-
-Create-llama is a monorepo containing CLI tools and server frameworks for building LlamaIndex-powered applications. The repository combines TypeScript/Node.js and Python components in a unified development environment.
-
-## Architecture
-
-### Monorepo Structure
-
- **`packages/create-llama/`**: Main CLI tool for scaffolding LlamaIndex applications
- **`packages/server/`**: TypeScript/Next.js server framework (`@llamaindex/server`)
- **`python/llama-index-server/`**: Python/FastAPI server framework
- **Root**: Workspace configuration and shared development tools
-
-### Key Technologies
-
- **Package Manager**: pnpm with workspace configuration
- **Build Tools**: bunchee (TypeScript), Next.js, hatchling (Python)
- **Testing**: Playwright for e2e, pytest for Python
- **Version Management**: changesets for TypeScript packages, manual for Python
-
-## Development Commands
-
-### Root Level (Monorepo)
-
-```bash
-pnpm dev          # Start all packages in development mode
-pnpm build        # Build all packages
-pnpm lint         # ESLint across TypeScript packages
-pnpm format       # Prettier formatting
-pnpm e2e          # Run end-to-end tests
-```
-
-### Create-llama Package
-
-```bash
-cd packages/create-llama
-npm run build     # Build CLI using bash script and ncc
-npm run dev       # Watch mode development
-npm run e2e       # Playwright tests for generated projects
-npm run clean     # Clean build artifacts and template caches
-```
-
-### TypeScript Server Package
-
-```bash
-cd packages/server
-pnpm dev          # Watch mode with bunchee
-pnpm build        # Multi-step build: ESM/CJS + Next.js + static assets
-pnpm clean        # Clean all build outputs
-```
-
-### Python Server Package
-
-```bash
-cd python/llama-index-server
-uv run generate   # Index data files
-fastapi dev       # Start development server with hot reload
-pytest            # Run test suite
-```
-
-## Template System
-
-The CLI uses a sophisticated template system in `packages/create-llama/templates/`:
-
-### Organization
-
- **`types/`**: Base project structures (streaming, reflex, llamaindexserver)
- **`components/`**: Reusable components across frameworks
-  - `engines/` - Chat and agent engines
-  - `loaders/` - File, web, database loaders
-  - `providers/` - AI model configurations
-  - `vectordbs/` - Vector database integrations
-  - `use-cases/` - Workflow implementations
-
-### Development Workflow
-
- Templates support multiple frameworks (Next.js, Express, FastAPI)
- Component system allows mix-and-match functionality
- E2E tests validate generated projects work correctly
-
-## Server Framework Architecture
-
-### TypeScript Server (`@llamaindex/server`)
-
- **Core**: `LlamaIndexServer` class wrapping Next.js with workflow support
- **Frontend**: React-based chat UI with shadcn/ui components
- **API**: `/api/chat` endpoint with streaming responses
- **Build Process**: Complex multi-step build including static assets for Python integration
-
-### Python Server (`llama-index-server`)
-
- **Core**: `LlamaIndexServer` class extending FastAPI
- **Architecture**: Workflow factory pattern for stateless request handling
- **UI Generation**: AI-powered React component generation from Pydantic schemas
- **Development**: Hot reloading support with dev mode
-
-## Common Patterns
-
-### Workflow Integration
-
-Both server frameworks use factory patterns:
-
-```typescript
-// TypeScript
-const server = new LlamaIndexServer({
-  workflow: (context) => createWorkflow(context)
-});
-
-// Python
-def create_workflow(chat_request: ChatRequest) -> Workflow:
-    return MyWorkflow(chat_request.messages)
-```
-
-### Event System
-
-Structured events for UI communication:
-
- **UIEvent**: Custom components with Pydantic/Zod schemas
- **ArtifactEvent**: Code/documents for Canvas panel
- **SourceNodesEvent**: Document sources with metadata
- **AgentRunEvent**: Tool usage and progress tracking
-
-### File Handling
-
- Both servers auto-mount `data/` and `output/` directories
- LlamaCloud integration for remote file access
- Static file serving through framework-specific methods
-
-## Testing Strategy
-
-### E2E Testing
-
- Playwright tests in `packages/create-llama/e2e/`
- Tests both Python and TypeScript generated projects
- Validates CLI generation and application functionality
-
-### Unit Testing
-
- Python: pytest with comprehensive API and service tests
- TypeScript: Integrated testing through build process
-
-## Build Process
-
-### Create-llama CLI
-
-1. TypeScript compilation with bash script
-2. ncc bundling for standalone executable
-3. Template validation and caching
-
-### Server Package Build
-
-1. **prebuild**: Clean directories
-2. **build**: bunchee compilation to ESM/CJS
-3. **postbuild**: Next.js preparation and static asset generation
-4. **prepare:py-static**: Python integration assets
-
-### Release Process
-
-```bash
-pnpm release     # Build all + publish npm packages + Python release
-```
-
-## Development Environment Setup
-
-### Prerequisites
-
- Node.js >=16.14.0
- Python with uv package manager
- pnpm for package management
-
-### Common Workflow
-
-1. Clone repository and run `pnpm install`
-2. For CLI development: work in `packages/create-llama/`
-3. For server development: choose TypeScript or Python package
-4. Use `pnpm dev` for concurrent development across packages
-5. Run `pnpm e2e` to validate changes with generated projects
-
-## Special Considerations
-
-### Template Development
-
- Changes to templates require rebuilding CLI
- E2E tests validate template functionality across frameworks
- Template caching system speeds up repeated builds
-
-### Cross-package Dependencies
-
- Server package builds static assets for Python integration
- Version synchronization between TypeScript and Python packages
- Shared UI components and styling across implementations
-
-### Performance
-
- CLI uses caching for template operations
- Server frameworks support streaming responses
- Background processing for file operations and LlamaCloud integration
@@ -25,10 +25,13 @@ to start the development server. You can then visit [http://localhost:3000](http
 ## What you'll get

 - A set of pre-configured use cases to get you started, e.g. Agentic RAG, Data Analysis, Report Generation, etc.
- A front-end using components from [shadcn/ui](https://ui.shadcn.com/). The app is set up as a chat interface that can answer questions about your data or interact with your agent
- Your choice of two frameworks:
-  - **Next.js**: if you select this option, you’ll have a full-stack Next.js application that you can deploy to a host like [Vercel](https://vercel.com/) in just a few clicks. This uses [LlamaIndex.TS](https://www.npmjs.com/package/llamaindex), our TypeScript library with [LlamaIndex Server for TS](https://npmjs.com/package/@llamaindex/server).
-  - **Python FastAPI**: if you select this option, you’ll get full-stack Python application powered by the [llama-index Python package](https://pypi.org/project/llama-index/) and [LlamaIndex Server for Python](https://pypi.org/project/llama-index-server/)
+- A Next.js-powered front-end using components from [shadcn/ui](https://ui.shadcn.com/). The app is set up as a chat interface that can answer questions about your data or interact with your agent
+- Your choice of two back-ends:
+  - **Next.js**: if you select this option, you’ll have a full-stack Next.js application that you can deploy to a host like [Vercel](https://vercel.com/) in just a few clicks. This uses [LlamaIndex.TS](https://www.npmjs.com/package/llamaindex), our TypeScript library.
+  - **Python FastAPI**: if you select this option, you’ll get a separate backend powered by the [llama-index Python package](https://pypi.org/project/llama-index/), which you can deploy to a service like [Render](https://render.com/) or [fly.io](https://fly.io/). The separate Next.js front-end will connect to this backend.
+- Each back-end has two endpoints:
+  - One streaming chat endpoint, that allow you to send the state of your chat and receive additional responses
+  - One endpoint to upload private files which can be used in your chat
 - The app uses OpenAI by default, so you'll need an OpenAI API key, or you can customize it to use any of the dozens of LLMs we support.

 Here's how it looks like:
@@ -37,11 +40,11 @@ https://github.com/user-attachments/assets/d57af1a1-d99b-4e9c-98d9-4cbd1327eff8

 ## Using your data

-Optionally, you can supply your own data; the app will index it and make use of it, e.g. to answer questions. Your generated app will have a folder called `data`.
+Optionally, you can supply your own data; the app will index it and make use of it, e.g. to answer questions. Your generated app will have a folder called `data` (If you're using Express or Python and generate a frontend, it will be `./backend/data`).

-The app will ingest any supported files you put in this directory. Your Next.js apps use LlamaIndex.TS, so they will be able to ingest any PDF, text, CSV, Markdown, Word and HTML files. The Python backend can read even more types, including video and audio files.
+The app will ingest any supported files you put in this directory. Your Next.js and Express apps use LlamaIndex.TS, so they will be able to ingest any PDF, text, CSV, Markdown, Word and HTML files. The Python backend can read even more types, including video and audio files.

-Before you can use your data, you need to index it. If you're using the Next.js apps, run:
+Before you can use your data, you need to index it. If you're using the Next.js or Express apps, run:

 ```bash
 npm run generate
@@ -52,16 +55,16 @@ Then re-start your app. Remember you'll need to re-run `generate` if you add new
 If you're using the Python backend, you can trigger indexing of your data by calling:

 ```bash
-uv run generate
+poetry run generate
 ```

 ## Customizing the AI models

-The app will default to OpenAI's `gpt-4.1` LLM and `text-embedding-3-large` embedding model.
+The app will default to OpenAI's `gpt-4o-mini` LLM and `text-embedding-3-large` embedding model.

-If you want to use different models, add the `--ask-models` CLI parameter.
+If you want to use different OpenAI models, add the `--ask-models` CLI parameter.

-You can also replace one of the default models with one of our [dozens of other supported LLMs](https://docs.llamaindex.ai/en/stable/module_guides/models/llms/modules.html).
+You can also replace OpenAI with one of our [dozens of other supported LLMs](https://docs.llamaindex.ai/en/stable/module_guides/models/llms/modules.html).

 To do so, you have to manually change the generated code (edit the `settings.ts` file for Typescript projects or the `settings.py` file for Python projects)

@@ -87,10 +90,11 @@ Need to install the following packages:
  create-llama@latest
 Ok to proceed? (y) y
 ✔ What is your project named? … my-app
-✔ What use case do you want to build? › Agentic RAG
+✔ What app do you want to build? › Agentic RAG
 ✔ What language do you want to use? › Python (FastAPI)
 ✔ Do you want to use LlamaCloud services? … No / Yes
 ✔ Please provide your LlamaCloud API key (leave blank to skip): …
+✔ Please provide your OpenAI API key (leave blank to skip): …
 ? How would you like to proceed? › - Use arrow-keys. Return to submit.
    Just generate code (~1 sec)
 ❯   Start in VSCode (~1 sec)
@@ -102,16 +106,28 @@ Ok to proceed? (y) y
 You can also pass command line arguments to set up a new project
 non-interactively. For a list of the latest options, call `create-llama --help`.

+### Running in pro mode
+
+If you prefer more advanced customization options, you can run `create-llama` in pro mode using the `--pro` flag.
+
+In pro mode, instead of selecting a predefined use case, you'll be prompted to select each technical component of your project. This allows for greater flexibility in customizing your project, including:
+
+- **Vector Store**: Choose from a variety of vector stores for keeping your documents, including MongoDB, Pinecone, Weaviate, Qdrant and Chroma.
+- **Tools**: Choose from a variety of agent tools (functions called by the LLM), such as:
+  - Code Interpreter: Executes Python code in a secure Jupyter notebook environment
+  - Artifact Code Generator: Generates code artifacts that can be run in a sandbox
+  - OpenAPI Action: Facilitates requests to a provided OpenAPI schema
+  - Image Generator: Creates images based on text descriptions
+  - Web Search: Performs web searches to retrieve up-to-date information
+- **Data Sources**: Integrate various data sources into your chat application, including local files, websites, or database-retrieved data.
+- **Backend Options**: Besides using Next.js or FastAPI, you can also select to use Express for a more traditional Node.js application.
+- **Observability**: Choose from a variety of LLM observability tools, including LlamaTrace and Traceloop.
+
+Pro mode is ideal for developers who want fine-grained control over their project's configuration and are comfortable with more technical setup options.
+
 ## LlamaIndex Documentation

 - [TS/JS docs](https://ts.llamaindex.ai/)
 - [Python docs](https://docs.llamaindex.ai/en/stable/)

-## LlamaIndex Server
-
-The generated code is using the LlamaIndex Server, which serves LlamaIndex Workflows and Agent Workflows via an API server. See the following docs for more information:
-
- [LlamaIndex Server For TypeScript](./packages/server/README.md)
- [LlamaIndex Server For Python](./python/llama-index-server/README.md)
-
 Inspired by and adapted from [create-next-app](https://github.com/vercel/next.js/tree/canary/packages/create-next-app)
@@ -1,34 +1,44 @@
+/* eslint-disable import/no-extraneous-dependencies */
 import path from "path";
 import { green, yellow } from "picocolors";
 import { tryGitInit } from "./helpers/git";
 import { isFolderEmpty } from "./helpers/is-folder-empty";
+import { getOnline } from "./helpers/is-online";
 import { isWriteable } from "./helpers/is-writeable";
 import { makeDir } from "./helpers/make-dir";

 import terminalLink from "terminal-link";
-import type { InstallTemplateArgs } from "./helpers";
+import type { InstallTemplateArgs, TemplateObservability } from "./helpers";
 import { installTemplate } from "./helpers";
 import { templatesDir } from "./helpers/dir";
+import { toolsRequireConfig } from "./helpers/tools";
 import { configVSCode } from "./helpers/vscode";

 export type InstallAppArgs = Omit<
  InstallTemplateArgs,
-  "appName" | "root" | "port"
+  "appName" | "root" | "isOnline" | "port"
 > & {
  appPath: string;
+  frontend: boolean;
 };

 export async function createApp({
  template,
  framework,
+  ui,
  appPath,
  packageManager,
+  frontend,
  modelConfig,
  llamaCloudKey,
+  communityProjectConfig,
+  llamapack,
  vectorDb,
  postInstallAction,
  dataSources,
+  tools,
  useLlamaParse,
+  observability,
  useCase,
 }: InstallAppArgs): Promise<void> {
  const root = path.resolve(appPath);
@@ -50,6 +60,9 @@ export async function createApp({
    process.exit(1);
  }

+  const useYarn = packageManager === "yarn";
+  const isOnline = !useYarn || (await getOnline());
+
  console.log(`Creating a new LlamaIndex app in ${green(root)}.`);
  console.log();

@@ -58,18 +71,36 @@ export async function createApp({
    root,
    template,
    framework,
+    ui,
    packageManager,
+    isOnline,
    modelConfig,
    llamaCloudKey,
+    communityProjectConfig,
+    llamapack,
    vectorDb,
    postInstallAction,
    dataSources,
+    tools,
    useLlamaParse,
+    observability,
    useCase,
  };

  // Install backend
-  await installTemplate(args);
+  await installTemplate({ ...args, backend: true });
+
+  if (frontend && framework === "fastapi" && template !== "llamaindexserver") {
+    // install frontend
+    const frontendRoot = path.join(root, ".frontend");
+    await makeDir(frontendRoot);
+    await installTemplate({
+      ...args,
+      root: frontendRoot,
+      framework: "nextjs",
+      backend: false,
+    });
+  }

  await configVSCode(root, templatesDir, framework);

@@ -79,6 +110,18 @@ export async function createApp({
    console.log();
  }

+  if (toolsRequireConfig(tools) && template !== "llamaindexserver") {
+    const configFile =
+      framework === "fastapi" ? "config/tools.yaml" : "config/tools.json";
+    console.log(
+      yellow(
+        `You have selected tools that require configuration. Please configure them in the ${terminalLink(
+          configFile,
+          `file://${root}/${configFile}`,
+        )} file.`,
+      ),
+    );
+  }
  console.log("");
  console.log(`${green("Success!")} Created ${appName} at ${appPath}`);

@@ -89,6 +132,8 @@ export async function createApp({
    )} and learn how to get started.`,
  );

+  outputObservability(args.observability);
+
  if (
    dataSources.some((dataSource) => dataSource.type === "file") &&
    process.platform === "linux"
@@ -105,3 +150,24 @@ export async function createApp({

  console.log();
 }
+
+function outputObservability(observability?: TemplateObservability) {
+  switch (observability) {
+    case "traceloop":
+      console.log(
+        `\n${yellow("Observability")}: Visit the ${terminalLink(
+          "documentation",
+          "https://traceloop.com/docs/openllmetry/integrations",
+        )} to set up the environment variables and start seeing execution traces.`,
+      );
+      break;
+    case "llamatrace":
+      console.log(
+        `\n${yellow("Observability")}: LlamaTrace has been configured for your project. Visit the ${terminalLink(
+          "LlamaTrace dashboard",
+          "https://llamatrace.com/login",
+        )} to view your traces and monitor your application.`,
+      );
+      break;
+  }
+}
@@ -0,0 +1,233 @@
+import { expect, test } from "@playwright/test";
+import { exec } from "child_process";
+import fs from "fs";
+import path from "path";
+import util from "util";
+import { TemplateFramework, TemplateVectorDB } from "../../helpers/types";
+import { RunCreateLlamaOptions, createTestDir, runCreateLlama } from "../utils";
+
+const execAsync = util.promisify(exec);
+
+const templateFramework: TemplateFramework = process.env.FRAMEWORK
+  ? (process.env.FRAMEWORK as TemplateFramework)
+  : "fastapi";
+const dataSource: string = process.env.DATASOURCE
+  ? process.env.DATASOURCE
+  : "--example-file";
+
+// TODO: add support for other templates
+
+if (
+  dataSource === "--example-file" // XXX: this test provides its own data source - only trigger it on one data source (usually the CI matrix will trigger multiple data sources)
+) {
+  // vectorDBs, tools, and data source combinations to test
+  const vectorDbs: TemplateVectorDB[] = [
+    "mongo",
+    "pg",
+    "pinecone",
+    "milvus",
+    "astra",
+    "qdrant",
+    "chroma",
+    "weaviate",
+  ];
+
+  const toolOptions = [
+    "wikipedia.WikipediaToolSpec",
+    "google.GoogleSearchToolSpec",
+    "document_generator",
+    "artifact",
+  ];
+
+  const dataSources = [
+    "--example-file",
+    "--web-source https://www.example.com",
+    "--db-source mysql+pymysql://user:pass@localhost:3306/mydb",
+  ];
+
+  const observabilityOptions = ["llamatrace", "traceloop"];
+
+  test.describe("Mypy check", () => {
+    test.describe.configure({ retries: 0 });
+
+    // Test vector databases
+    for (const vectorDb of vectorDbs) {
+      test(`Mypy check for vectorDB: ${vectorDb}`, async () => {
+        const cwd = await createTestDir();
+        const { pyprojectPath } = await createAndCheckLlamaProject({
+          options: {
+            cwd,
+            templateType: "streaming",
+            templateFramework,
+            dataSource: "--example-file",
+            vectorDb,
+            tools: "none",
+            port: 3000,
+            postInstallAction: "none",
+            templateUI: undefined,
+            appType: "--no-frontend",
+            llamaCloudProjectName: undefined,
+            llamaCloudIndexName: undefined,
+            observability: undefined,
+          },
+        });
+
+        const pyprojectContent = fs.readFileSync(pyprojectPath, "utf-8");
+        if (vectorDb !== "none") {
+          if (vectorDb === "pg") {
+            expect(pyprojectContent).toContain(
+              "llama-index-vector-stores-postgres",
+            );
+          } else {
+            expect(pyprojectContent).toContain(
+              `llama-index-vector-stores-${vectorDb}`,
+            );
+          }
+        }
+      });
+    }
+
+    // Test tools
+    for (const tool of toolOptions) {
+      test(`Mypy check for tool: ${tool}`, async () => {
+        const cwd = await createTestDir();
+        const { pyprojectPath } = await createAndCheckLlamaProject({
+          options: {
+            cwd,
+            templateType: "streaming",
+            templateFramework,
+            dataSource: "--example-file",
+            vectorDb: "none",
+            tools: tool,
+            port: 3000,
+            postInstallAction: "none",
+            templateUI: undefined,
+            appType: "--no-frontend",
+            llamaCloudProjectName: undefined,
+            llamaCloudIndexName: undefined,
+            observability: undefined,
+          },
+        });
+
+        const pyprojectContent = fs.readFileSync(pyprojectPath, "utf-8");
+        if (tool === "wikipedia.WikipediaToolSpec") {
+          expect(pyprojectContent).toContain("wikipedia");
+        }
+        if (tool === "google.GoogleSearchToolSpec") {
+          expect(pyprojectContent).toContain("google");
+        }
+      });
+    }
+
+    // Test data sources
+    for (const dataSource of dataSources) {
+      const dataSourceType = dataSource.split(" ")[0];
+      test(`Mypy check for data source: ${dataSourceType}`, async () => {
+        const cwd = await createTestDir();
+        const { pyprojectPath } = await createAndCheckLlamaProject({
+          options: {
+            cwd,
+            templateType: "streaming",
+            templateFramework,
+            dataSource,
+            vectorDb: "none",
+            tools: "none",
+            port: 3000,
+            postInstallAction: "none",
+            templateUI: undefined,
+            appType: "--no-frontend",
+            llamaCloudProjectName: undefined,
+            llamaCloudIndexName: undefined,
+            observability: undefined,
+          },
+        });
+
+        const pyprojectContent = fs.readFileSync(pyprojectPath, "utf-8");
+        if (dataSource.includes("--web-source")) {
+          expect(pyprojectContent).toContain("llama-index-readers-web");
+        }
+        if (dataSource.includes("--db-source")) {
+          expect(pyprojectContent).toContain("llama-index-readers-database");
+        }
+      });
+    }
+
+    // Test observability options
+    for (const observability of observabilityOptions) {
+      test(`Mypy check for observability: ${observability}`, async () => {
+        const cwd = await createTestDir();
+
+        const { pyprojectPath } = await createAndCheckLlamaProject({
+          options: {
+            cwd,
+            templateType: "streaming",
+            templateFramework,
+            dataSource: "--example-file",
+            vectorDb: "none",
+            tools: "none",
+            port: 3000,
+            postInstallAction: "none",
+            templateUI: undefined,
+            appType: "--no-frontend",
+            llamaCloudProjectName: undefined,
+            llamaCloudIndexName: undefined,
+            observability,
+          },
+        });
+      });
+    }
+  });
+}
+
+async function createAndCheckLlamaProject({
+  options,
+}: {
+  options: RunCreateLlamaOptions;
+}): Promise<{ pyprojectPath: string; projectPath: string }> {
+  const result = await runCreateLlama(options);
+  const name = result.projectName;
+  const projectPath = path.join(options.cwd, name);
+
+  // Check if the app folder exists
+  expect(fs.existsSync(projectPath)).toBeTruthy();
+
+  // Check if pyproject.toml exists
+  const pyprojectPath = path.join(projectPath, "pyproject.toml");
+  expect(fs.existsSync(pyprojectPath)).toBeTruthy();
+
+  const env = {
+    ...process.env,
+    POETRY_VIRTUALENVS_IN_PROJECT: "true",
+  };
+
+  // Run poetry install
+  try {
+    const { stdout: installStdout, stderr: installStderr } = await execAsync(
+      "poetry install",
+      { cwd: projectPath, env },
+    );
+    console.log("poetry install stdout:", installStdout);
+    console.error("poetry install stderr:", installStderr);
+  } catch (error) {
+    console.error("Error running poetry install:", error);
+    throw error;
+  }
+
+  // Run poetry run mypy
+  try {
+    const { stdout: mypyStdout, stderr: mypyStderr } = await execAsync(
+      "poetry run mypy .",
+      { cwd: projectPath, env },
+    );
+    console.log("poetry run mypy stdout:", mypyStdout);
+    console.error("poetry run mypy stderr:", mypyStderr);
+  } catch (error) {
+    console.error("Error running mypy:", error);
+    throw error;
+  }
+
+  // If we reach this point without throwing an error, the test passes
+  expect(true).toBeTruthy();
+
+  return { pyprojectPath, projectPath };
+}
@@ -1,44 +1,54 @@
+/* eslint-disable turbo/no-undeclared-env-vars */
 import { expect, test } from "@playwright/test";
 import { ChildProcess } from "child_process";
 import fs from "fs";
 import path from "path";
-import {
-  ALL_USE_CASES,
-  type TemplateFramework,
-  type TemplateVectorDB,
+import type {
+  TemplateFramework,
+  TemplatePostInstallAction,
+  TemplateUI,
 } from "../../helpers";
-import { createTestDir, runCreateLlama } from "../utils";
+import { createTestDir, runCreateLlama, type AppType } from "../utils";

 const templateFramework: TemplateFramework = process.env.FRAMEWORK
  ? (process.env.FRAMEWORK as TemplateFramework)
  : "fastapi";
-const vectorDb: TemplateVectorDB = process.env.VECTORDB
-  ? (process.env.VECTORDB as TemplateVectorDB)
-  : "none";
-const llamaCloudProjectName = "create-llama";
-const llamaCloudIndexName = "e2e-test";
-
+const dataSource: string = "--example-file";
+const templateUI: TemplateUI = "shadcn";
+const templatePostInstallAction: TemplatePostInstallAction = "runApp";
+const appType: AppType = "--frontend";
 const userMessage = "Write a blog post about physical standards for letters";
+const templateUseCases = ["financial_report", "agentic_rag", "deep_research"];

-for (const useCase of ALL_USE_CASES) {
-  test.describe(`Test use case ${useCase} ${templateFramework} ${vectorDb}`, async () => {
+for (const useCase of templateUseCases) {
+  test.describe(`Test use case ${useCase} ${templateFramework} ${dataSource} ${templateUI} ${appType} ${templatePostInstallAction}`, async () => {
+    test.skip(
+      process.platform !== "linux" ||
+        process.env.DATASOURCE === "--no-files" ||
+        templateFramework === "express",
+      "The llamaindexserver template currently only works with nextjs, fastapi. We also only run on Linux to speed up tests.",
+    );
    let port: number;
    let cwd: string;
    let name: string;
    let appProcess: ChildProcess;
+    // Only test without using vector db for now
+    const vectorDb = "none";

    test.beforeAll(async () => {
      port = Math.floor(Math.random() * 10000) + 10000;
      cwd = await createTestDir();
      const result = await runCreateLlama({
        cwd,
+        templateType: "llamaindexserver",
        templateFramework,
+        dataSource,
        vectorDb,
        port,
-        postInstallAction: "runApp",
+        postInstallAction: templatePostInstallAction,
+        templateUI,
+        appType,
        useCase,
-        llamaCloudProjectName,
-        llamaCloudIndexName,
      });
      name = result.projectName;
      appProcess = result.appProcess;
@@ -50,6 +60,10 @@ for (const useCase of ALL_USE_CASES) {
    });

    test("Frontend should have a title", async ({ page }) => {
+      test.skip(
+        templatePostInstallAction !== "runApp" ||
+          templateFramework === "express",
+      );
      await page.goto(`http://localhost:${port}`);
      await expect(page.getByText("Built by LlamaIndex")).toBeVisible({
        timeout: 5 * 60 * 1000,
@@ -60,7 +74,10 @@ for (const useCase of ALL_USE_CASES) {
      page,
    }) => {
      test.skip(
-        useCase === "financial_report" || useCase === "deep_research",
+        templatePostInstallAction !== "runApp" ||
+          useCase === "financial_report" ||
+          useCase === "deep_research" ||
+          templateFramework === "express",
        "Skip chat tests for financial report and deep research.",
      );
      await page.goto(`http://localhost:${port}`);
@@ -0,0 +1,64 @@
+/* eslint-disable turbo/no-undeclared-env-vars */
+import { expect, test } from "@playwright/test";
+import { ChildProcess } from "child_process";
+import fs from "fs";
+import path from "path";
+import { TemplateFramework, TemplateUseCase } from "../../helpers";
+import { createTestDir, runCreateLlama } from "../utils";
+
+const templateFramework: TemplateFramework = process.env.FRAMEWORK
+  ? (process.env.FRAMEWORK as TemplateFramework)
+  : "fastapi";
+const dataSource: string = process.env.DATASOURCE
+  ? process.env.DATASOURCE
+  : "--example-file";
+const templateUseCases: TemplateUseCase[] = ["extractor", "contract_review"];
+
+// The reflex template currently only works with FastAPI and files (and not on Windows)
+if (
+  process.platform !== "win32" &&
+  templateFramework === "fastapi" &&
+  dataSource === "--example-file"
+) {
+  for (const useCase of templateUseCases) {
+    test.describe(`Test reflex template ${useCase} ${templateFramework} ${dataSource}`, async () => {
+      let appPort: number;
+      let name: string;
+      let appProcess: ChildProcess;
+      let cwd: string;
+
+      // Create reflex app
+      test.beforeAll(async () => {
+        cwd = await createTestDir();
+        appPort = Math.floor(Math.random() * 10000) + 10000;
+        const result = await runCreateLlama({
+          cwd,
+          templateType: "reflex",
+          templateFramework: "fastapi",
+          dataSource: "--example-file",
+          vectorDb: "none",
+          port: appPort,
+          postInstallAction: "runApp",
+          useCase,
+        });
+        name = result.projectName;
+        appProcess = result.appProcess;
+      });
+
+      test.afterAll(async () => {
+        appProcess.kill();
+      });
+
+      test("App folder should exist", async () => {
+        const dirExists = fs.existsSync(path.join(cwd, name));
+        expect(dirExists).toBeTruthy();
+      });
+      test("Frontend should have a title", async ({ page }) => {
+        await page.goto(`http://localhost:${appPort}`);
+        await expect(page.getByText("Built by LlamaIndex")).toBeVisible({
+          timeout: 2000 * 60,
+        });
+      });
+    });
+  }
+}
@@ -0,0 +1,128 @@
+/* eslint-disable turbo/no-undeclared-env-vars */
+import { expect, test } from "@playwright/test";
+import { ChildProcess } from "child_process";
+import fs from "fs";
+import path from "path";
+import type {
+  TemplateFramework,
+  TemplatePostInstallAction,
+  TemplateUI,
+} from "../../helpers";
+import { createTestDir, runCreateLlama, type AppType } from "../utils";
+
+const templateFramework: TemplateFramework = process.env.FRAMEWORK
+  ? (process.env.FRAMEWORK as TemplateFramework)
+  : "fastapi";
+const dataSource: string = process.env.DATASOURCE
+  ? process.env.DATASOURCE
+  : "--example-file";
+const templateUI: TemplateUI = "shadcn";
+const templatePostInstallAction: TemplatePostInstallAction = "runApp";
+
+const llamaCloudProjectName = "create-llama";
+const llamaCloudIndexName = "e2e-test";
+
+const appType: AppType = templateFramework === "fastapi" ? "--frontend" : "";
+const userMessage =
+  dataSource !== "--no-files" ? "Physical standard for letters" : "Hello";
+
+test.describe(`Test streaming template ${templateFramework} ${dataSource} ${templateUI} ${appType} ${templatePostInstallAction}`, async () => {
+  const isNode18 = process.version.startsWith("v18");
+  const isLlamaCloud = dataSource === "--llamacloud";
+  // llamacloud is using File API which is not supported on node 18
+  if (isNode18 && isLlamaCloud) {
+    test.skip(true, "Skipping tests for Node 18 and LlamaCloud data source");
+  }
+
+  let port: number;
+  let cwd: string;
+  let name: string;
+  let appProcess: ChildProcess;
+  // Only test without using vector db for now
+  const vectorDb = "none";
+
+  test.beforeAll(async () => {
+    port = Math.floor(Math.random() * 10000) + 10000;
+    cwd = await createTestDir();
+    const result = await runCreateLlama({
+      cwd,
+      templateType: "streaming",
+      templateFramework,
+      dataSource,
+      vectorDb,
+      port,
+      postInstallAction: templatePostInstallAction,
+      templateUI,
+      appType,
+      llamaCloudProjectName,
+      llamaCloudIndexName,
+    });
+    name = result.projectName;
+    appProcess = result.appProcess;
+  });
+
+  test("App folder should exist", async () => {
+    const dirExists = fs.existsSync(path.join(cwd, name));
+    expect(dirExists).toBeTruthy();
+  });
+
+  test("Frontend should have a title", async ({ page }) => {
+    test.skip(
+      templatePostInstallAction !== "runApp" || templateFramework === "express",
+    );
+    await page.goto(`http://localhost:${port}`);
+    await expect(page.getByText("Built by LlamaIndex")).toBeVisible();
+  });
+
+  test("Frontend should be able to submit a message and receive a response", async ({
+    page,
+  }) => {
+    test.skip(
+      templatePostInstallAction !== "runApp" || templateFramework === "express",
+    );
+    await page.goto(`http://localhost:${port}`);
+    await page.fill("form textarea", userMessage);
+    const [response] = await Promise.all([
+      page.waitForResponse(
+        (res) => {
+          return res.url().includes("/api/chat") && res.status() === 200;
+        },
+        {
+          timeout: 1000 * 60,
+        },
+      ),
+      page.click("form button[type=submit]"),
+    ]);
+    const text = await response.text();
+    console.log("AI response when submitting message: ", text);
+    expect(response.ok()).toBeTruthy();
+  });
+
+  test("Backend frameworks should response when calling non-streaming chat API", async ({
+    request,
+  }) => {
+    test.skip(templatePostInstallAction !== "runApp");
+    test.skip(templateFramework === "nextjs");
+    const response = await request.post(
+      `http://localhost:${port}/api/chat/request`,
+      {
+        data: {
+          messages: [
+            {
+              role: "user",
+              content: userMessage,
+            },
+          ],
+        },
+      },
+    );
+    const text = await response.text();
+    console.log("AI response when calling API: ", text);
+    expect(response.ok()).toBeTruthy();
+  });
+
+  // clean processes
+  test.afterAll(async () => {
+    appProcess?.kill();
+  });
+});
@@ -0,0 +1,105 @@
+import { expect, test } from "@playwright/test";
+import { exec } from "child_process";
+import fs from "fs";
+import path from "path";
+import util from "util";
+import { TemplateFramework, TemplateVectorDB } from "../../helpers/types";
+import { createTestDir, runCreateLlama } from "../utils";
+
+const execAsync = util.promisify(exec);
+
+const templateFramework: TemplateFramework = process.env.FRAMEWORK
+  ? (process.env.FRAMEWORK as TemplateFramework)
+  : "nextjs";
+const dataSource: string = process.env.DATASOURCE
+  ? process.env.DATASOURCE
+  : "--example-file";
+
+// vectorDBs combinations to test
+const vectorDbs: TemplateVectorDB[] = [
+  "mongo",
+  "pg",
+  "qdrant",
+  "pinecone",
+  "milvus",
+  "astra",
+  "chroma",
+  "llamacloud",
+  "weaviate",
+];
+
+test.describe("Test resolve TS dependencies", () => {
+  // Test vector DBs without LlamaParse
+  for (const vectorDb of vectorDbs) {
+    const optionDescription = `vectorDb: ${vectorDb}, dataSource: ${dataSource}`;
+
+    test(`Vector DB test - ${optionDescription}`, async () => {
+      await runTest(vectorDb, false);
+    });
+  }
+
+  // Test LlamaParse with vectorDB 'none'
+  test(`LlamaParse test - vectorDb: none, dataSource: ${dataSource}, llamaParse: true`, async () => {
+    await runTest("none", true);
+  });
+
+  async function runTest(
+    vectorDb: TemplateVectorDB | "none",
+    useLlamaParse: boolean,
+  ) {
+    const cwd = await createTestDir();
+
+    const result = await runCreateLlama({
+      cwd: cwd,
+      templateType: "streaming",
+      templateFramework: templateFramework,
+      dataSource: dataSource,
+      vectorDb: vectorDb,
+      port: 3000,
+      postInstallAction: "none",
+      templateUI: undefined,
+      appType: templateFramework === "nextjs" ? "" : "--no-frontend",
+      llamaCloudProjectName: undefined,
+      llamaCloudIndexName: undefined,
+      tools: undefined,
+      useLlamaParse: useLlamaParse,
+    });
+    const name = result.projectName;
+
+    // Check if the app folder exists
+    const appDir = path.join(cwd, name);
+    const dirExists = fs.existsSync(appDir);
+    expect(dirExists).toBeTruthy();
+
+    // Install dependencies using pnpm
+    try {
+      const { stderr: installStderr } = await execAsync(
+        "pnpm install --prefer-offline",
+        {
+          cwd: appDir,
+        },
+      );
+    } catch (error) {
+      console.error("Error installing dependencies:", error);
+      throw error;
+    }
+
+    // Run tsc type check and capture the output
+    try {
+      const { stdout, stderr } = await execAsync(
+        "pnpm exec tsc -b --diagnostics",
+        {
+          cwd: appDir,
+        },
+      );
+      // Check if there's any error output
+      expect(stderr).toBeFalsy();
+
+      // Log the stdout for debugging purposes
+      console.log("TypeScript type-check output:", stdout);
+    } catch (error) {
+      console.error("Error running tsc:", error);
+      throw error;
+    }
+  }
+});
@@ -6,9 +6,13 @@ import waitPort from "wait-port";
 import {
  TemplateFramework,
  TemplatePostInstallAction,
+  TemplateType,
+  TemplateUI,
  TemplateVectorDB,
 } from "../helpers";

+export type AppType = "--frontend" | "--no-frontend" | "";
+
 export type CreateLlamaResult = {
  projectName: string;
  appProcess: ChildProcess;
@@ -16,36 +20,72 @@ export type CreateLlamaResult = {

 export type RunCreateLlamaOptions = {
  cwd: string;
+  templateType: TemplateType;
  templateFramework: TemplateFramework;
+  dataSource: string;
  vectorDb: TemplateVectorDB;
  port: number;
  postInstallAction: TemplatePostInstallAction;
-  useCase: string;
+  templateUI?: TemplateUI;
+  appType?: AppType;
  llamaCloudProjectName?: string;
  llamaCloudIndexName?: string;
+  tools?: string;
+  useLlamaParse?: boolean;
+  observability?: string;
+  useCase?: string;
 };

 export async function runCreateLlama({
  cwd,
+  templateType,
  templateFramework,
+  dataSource,
  vectorDb,
  port,
  postInstallAction,
-  useCase,
+  templateUI,
+  appType,
  llamaCloudProjectName,
  llamaCloudIndexName,
+  tools,
+  useLlamaParse,
+  observability,
+  useCase,
 }: RunCreateLlamaOptions): Promise<CreateLlamaResult> {
  if (!process.env.OPENAI_API_KEY || !process.env.LLAMA_CLOUD_API_KEY) {
    throw new Error(
      "Setting the OPENAI_API_KEY and LLAMA_CLOUD_API_KEY is mandatory to run tests",
    );
  }
-  const name = [templateFramework, useCase, vectorDb].join("-");
+  const name = [
+    templateType,
+    templateFramework,
+    dataSource.split(" ")[0],
+    templateUI,
+    appType,
+  ].join("-");
+
+  // Handle different data source types
+  let dataSourceArgs = [];
+  if (dataSource.includes("--web-source" || "--db-source")) {
+    const webSource = dataSource.split(" ")[1];
+    dataSourceArgs.push("--web-source", webSource);
+  } else if (dataSource.includes("--db-source")) {
+    const dbSource = dataSource.split(" ")[1];
+    dataSourceArgs.push("--db-source", dbSource);
+  } else {
+    dataSourceArgs.push(dataSource);
+  }
+
  const commandArgs = [
    "create-llama",
    name,
+    "--template",
+    templateType,
    "--framework",
    templateFramework,
+    ...dataSourceArgs,
    "--vector-db",
    vectorDb,
    "--use-npm",
@@ -53,10 +93,35 @@ export async function runCreateLlama({
    port,
    "--post-install-action",
    postInstallAction,
-    "--use-case",
-    useCase,
+    "--tools",
+    tools ?? "none",
+    "--observability",
+    "none",
  ];

+  if (templateUI) {
+    commandArgs.push("--ui", templateUI);
+  }
+  if (appType) {
+    commandArgs.push(appType);
+  }
+  if (useLlamaParse) {
+    commandArgs.push("--use-llama-parse");
+  } else {
+    commandArgs.push("--no-llama-parse");
+  }
+  if (observability) {
+    commandArgs.push("--observability", observability);
+  }
+  if (
+    (templateType === "multiagent" ||
+      templateType === "reflex" ||
+      templateType === "llamaindexserver") &&
+    useCase
+  ) {
+    commandArgs.push("--use-case", useCase);
+  }
+
  const command = commandArgs.join(" ");
  console.log(`running command '${command}' in ${cwd}`);
  const appProcess = exec(command, {
@@ -1,65 +0,0 @@
-import eslint from "@eslint/js";
-import eslintConfigPrettier from "eslint-config-prettier";
-import globals from "globals";
-import tseslint from "typescript-eslint";
-
-export default tseslint.config(
-  eslint.configs.recommended,
-  ...tseslint.configs.recommended,
-  eslintConfigPrettier,
-  {
-    languageOptions: {
-      ecmaVersion: 2022,
-      sourceType: "module",
-      globals: {
-        ...globals.browser,
-        ...globals.node,
-      },
-    },
-  },
-  {
-    files: ["packages/create-llama/**"],
-    rules: {
-      "max-params": ["error", 4],
-      "prefer-const": "error",
-      "no-empty": "off",
-      "no-extra-boolean-cast": "off",
-      "@typescript-eslint/no-explicit-any": "off",
-      "@typescript-eslint/no-unused-vars": "off",
-      "@typescript-eslint/no-empty-object-type": "off",
-      "@typescript-eslint/no-wrapper-object-types": "off",
-      "@typescript-eslint/ban-ts-comment": "off",
-    },
-  },
-  {
-    files: ["packages/server/**"],
-    rules: {
-      "no-irregular-whitespace": "off",
-      "@typescript-eslint/no-unused-vars": "off",
-      "@typescript-eslint/no-explicit-any": [
-        "error",
-        {
-          ignoreRestArgs: true,
-        },
-      ],
-    },
-  },
-  {
-    ignores: [
-      "python/**",
-      "**/*.mypy_cache/**",
-      "**/*.venv/**",
-      "**/*.ruff_cache/**",
-      "**/dist/**",
-      "**/e2e/cache/**",
-      "**/lib/*",
-      "**/.next/**",
-      "**/out/**",
-      "**/node_modules/**",
-      "**/build/**",
-      "packages/server/server/**",
-      "packages/server/project/**",
-      "packages/server/bin/**",
-    ],
-  },
-);
@@ -0,0 +1,6 @@
+export const COMMUNITY_OWNER = "run-llama";
+export const COMMUNITY_REPO = "create_llama_projects";
+export const LLAMA_PACK_OWNER = "run-llama";
+export const LLAMA_PACK_REPO = "llama_index";
+export const LLAMA_PACK_FOLDER = "llama-index-packs";
+export const LLAMA_PACK_FOLDER_PATH = `${LLAMA_PACK_OWNER}/${LLAMA_PACK_REPO}/main/${LLAMA_PACK_FOLDER}`;
@@ -1,3 +1,4 @@
+/* eslint-disable import/no-extraneous-dependencies */
 import { async as glob } from "fast-glob";
 import fs from "fs";
 import path from "path";
@@ -0,0 +1,142 @@
+import fs from "fs/promises";
+import path from "path";
+import yaml, { Document } from "yaml";
+import { templatesDir } from "./dir";
+import { DbSourceConfig, TemplateDataSource, WebSourceConfig } from "./types";
+
+export const EXAMPLE_FILE: TemplateDataSource = {
+  type: "file",
+  config: {
+    path: path.join(templatesDir, "components", "data", "101.pdf"),
+  },
+};
+
+export const EXAMPLE_10K_SEC_FILES: TemplateDataSource[] = [
+  {
+    type: "file",
+    config: {
+      url: new URL(
+        "https://s2.q4cdn.com/470004039/files/doc_earnings/2023/q4/filing/_10-K-Q4-2023-As-Filed.pdf",
+      ),
+      filename: "apple_10k_report.pdf",
+    },
+  },
+  {
+    type: "file",
+    config: {
+      url: new URL(
+        "https://ir.tesla.com/_flysystem/s3/sec/000162828024002390/tsla-20231231-gen.pdf",
+      ),
+      filename: "tesla_10k_report.pdf",
+    },
+  },
+];
+
+export const EXAMPLE_GDPR: TemplateDataSource = {
+  type: "file",
+  config: {
+    url: new URL(
+      "https://eur-lex.europa.eu/legal-content/EN/TXT/PDF/?uri=CELEX:32016R0679",
+    ),
+    filename: "gdpr.pdf",
+  },
+};
+
+export const AI_REPORTS: TemplateDataSource = {
+  type: "file",
+  config: {
+    url: new URL(
+      "https://www.europarl.europa.eu/RegData/etudes/ATAG/2024/760392/EPRS_ATA(2024)760392_EN.pdf",
+    ),
+    filename: "EPRS_ATA_2024_760392_EN.pdf",
+  },
+};
+
+export function getDataSources(
+  files?: string,
+  exampleFile?: boolean,
+): TemplateDataSource[] | undefined {
+  let dataSources: TemplateDataSource[] | undefined = undefined;
+  if (files) {
+    // If user specified files option, then the program should use context engine
+    dataSources = files.split(",").map((filePath) => ({
+      type: "file",
+      config: {
+        path: filePath,
+      },
+    }));
+  }
+  if (exampleFile) {
+    dataSources = [...(dataSources ? dataSources : []), EXAMPLE_FILE];
+  }
+  return dataSources;
+}
+
+export async function writeLoadersConfig(
+  root: string,
+  dataSources: TemplateDataSource[],
+  useLlamaParse?: boolean,
+) {
+  const loaderConfig: Record<string, any> = {};
+
+  // Always set file loader config
+  loaderConfig.file = createFileLoaderConfig(useLlamaParse);
+
+  if (dataSources.some((ds) => ds.type === "web")) {
+    loaderConfig.web = createWebLoaderConfig(dataSources);
+  }
+
+  const dbLoaders = dataSources.filter((ds) => ds.type === "db");
+  if (dbLoaders.length > 0) {
+    loaderConfig.db = createDbLoaderConfig(dbLoaders);
+  }
+
+  // Create a new Document with the loaderConfig
+  const yamlDoc = new Document(loaderConfig);
+
+  // Write loaders config
+  const loaderConfigPath = path.join(root, "config", "loaders.yaml");
+  await fs.mkdir(path.join(root, "config"), { recursive: true });
+  await fs.writeFile(loaderConfigPath, yaml.stringify(yamlDoc));
+}
+
+function createWebLoaderConfig(dataSources: TemplateDataSource[]): any {
+  const webLoaderConfig: Record<string, any> = {};
+
+  // Create config for browser driver arguments
+  webLoaderConfig.driver_arguments = [
+    "--no-sandbox",
+    "--disable-dev-shm-usage",
+  ];
+
+  // Create config for urls
+  const urlConfigs = dataSources
+    .filter((ds) => ds.type === "web")
+    .map((ds) => {
+      const dsConfig = ds.config as WebSourceConfig;
+      return {
+        base_url: dsConfig.baseUrl,
+        prefix: dsConfig.prefix,
+        depth: dsConfig.depth,
+      };
+    });
+  webLoaderConfig.urls = urlConfigs;
+
+  return webLoaderConfig;
+}
+
+function createFileLoaderConfig(useLlamaParse?: boolean): any {
+  return {
+    use_llama_parse: useLlamaParse,
+  };
+}
+
+function createDbLoaderConfig(dbLoaders: TemplateDataSource[]): any {
+  return dbLoaders.map((ds) => {
+    const dsConfig = ds.config as DbSourceConfig;
+    return {
+      uri: dsConfig.uri,
+      queries: [dsConfig.queries],
+    };
+  });
+}
@@ -1,15 +1,24 @@
 import fs from "fs/promises";
 import path from "path";
+import { TOOL_SYSTEM_PROMPT_ENV_VAR, Tool } from "./tools";
 import {
  InstallTemplateArgs,
  ModelConfig,
+  TemplateDataSource,
  TemplateFramework,
+  TemplateObservability,
  TemplateType,
  TemplateVectorDB,
 } from "./types";

 import { TSYSTEMS_LLMHUB_API_URL } from "./providers/llmhub";

+const DEFAULT_SYSTEM_PROMPT =
+  "You are a helpful assistant who helps users with their questions.";
+
+const DATA_SOURCES_PROMPT =
+  "You have access to a knowledge base including the facts that you should start with to find the answer for the user question. Use the query engine tool to retrieve the facts from the knowledge base.";
+
 export type EnvVar = {
  name?: string;
  description?: string;
@@ -172,7 +181,7 @@ const getVectorDBEnvs = (
            ]
          : []),
      ];
-    case "chroma": {
+    case "chroma":
      const envs = [
        {
          name: "CHROMA_COLLECTION",
@@ -197,7 +206,6 @@ Otherwise, use CHROMA_HOST and CHROMA_PORT config above`,
        });
      }
      return envs;
-    }
    case "weaviate":
      return [
        {
@@ -230,6 +238,11 @@ Otherwise, use CHROMA_HOST and CHROMA_PORT config above`,

 const getModelEnvs = (modelConfig: ModelConfig): EnvVar[] => {
  return [
+    {
+      name: "MODEL_PROVIDER",
+      description: "The provider for the AI models to use.",
+      value: modelConfig.provider,
+    },
    {
      name: "MODEL",
      description: "The name of LLM model to use.",
@@ -240,6 +253,11 @@ const getModelEnvs = (modelConfig: ModelConfig): EnvVar[] => {
      description: "Name of the embedding model to use.",
      value: modelConfig.embeddingModel,
    },
+    {
+      name: "EMBEDDING_DIM",
+      description: "Dimension of the embedding model to use.",
+      value: modelConfig.dimensions.toString(),
+    },
    {
      name: "CONVERSATION_STARTERS",
      description: "The questions to help users get started (multi-line).",
@@ -367,10 +385,25 @@ const getModelEnvs = (modelConfig: ModelConfig): EnvVar[] => {

 const getFrameworkEnvs = (
  framework: TemplateFramework,
+  template: TemplateType,
  port?: number,
 ): EnvVar[] => {
  const sPort = port?.toString() || "8000";
-  const result: EnvVar[] = [];
+  const result: EnvVar[] =
+    template !== "llamaindexserver"
+      ? [
+          {
+            name: "FILESERVER_URL_PREFIX",
+            description:
+              "FILESERVER_URL_PREFIX is the URL prefix of the server storing the images generated by the interpreter.",
+            value:
+              framework === "nextjs"
+                ? // FIXME: if we are using nextjs, port should be 3000
+                  "http://localhost:3000/api/files"
+                : `http://localhost:${sPort}/api/files`,
+          },
+        ]
+      : [];
  if (framework === "fastapi") {
    result.push(
      ...[
@@ -387,10 +420,149 @@ const getFrameworkEnvs = (
      ],
    );
  }
-
+  if (framework === "nextjs" && template !== "llamaindexserver") {
+    result.push({
+      name: "NEXT_PUBLIC_CHAT_API",
+      description:
+        "The API for the chat endpoint. Set when using a custom backend (e.g. Express). Use full URL like http://localhost:8000/api/chat",
+    });
+  }
  return result;
 };

+const getEngineEnvs = (): EnvVar[] => {
+  return [
+    {
+      name: "TOP_K",
+      description:
+        "The number of similar embeddings to return when retrieving documents.",
+    },
+  ];
+};
+
+const getToolEnvs = (tools?: Tool[]): EnvVar[] => {
+  if (!tools?.length) return [];
+  const toolEnvs: EnvVar[] = [];
+  tools.forEach((tool) => {
+    if (tool.envVars?.length) {
+      toolEnvs.push(
+        // Don't include the system prompt env var here
+        // It should be handled separately by merging with the default system prompt
+        ...tool.envVars.filter(
+          (env) => env.name !== TOOL_SYSTEM_PROMPT_ENV_VAR,
+        ),
+      );
+    }
+  });
+  return toolEnvs;
+};
+
+const getSystemPromptEnv = (
+  tools?: Tool[],
+  dataSources?: TemplateDataSource[],
+  template?: TemplateType,
+): EnvVar[] => {
+  const systemPromptEnv: EnvVar[] = [];
+  // build tool system prompt by merging all tool system prompts
+  // multiagent template doesn't need system prompt
+  if (template !== "multiagent") {
+    let toolSystemPrompt = "";
+    tools?.forEach((tool) => {
+      const toolSystemPromptEnv = tool.envVars?.find(
+        (env) => env.name === TOOL_SYSTEM_PROMPT_ENV_VAR,
+      );
+      if (toolSystemPromptEnv) {
+        toolSystemPrompt += toolSystemPromptEnv.value + "\n";
+      }
+    });
+
+    const systemPrompt =
+      '"' +
+      DEFAULT_SYSTEM_PROMPT +
+      (dataSources?.length ? `\n${DATA_SOURCES_PROMPT}` : "") +
+      (toolSystemPrompt ? `\n${toolSystemPrompt}` : "") +
+      '"';
+
+    systemPromptEnv.push({
+      name: "SYSTEM_PROMPT",
+      description: "The system prompt for the AI model.",
+      value: systemPrompt,
+    });
+  }
+  if (tools?.length == 0 && (dataSources?.length ?? 0 > 0)) {
+    const citationPrompt = `'You have provided information from a knowledge base that has been passed to you in nodes of information.
+Each node has useful metadata such as node ID, file name, page, etc.
+Please add the citation to the data node for each sentence or paragraph that you reference in the provided information.
+The citation format is: . [citation:<node_id>]()
+Where the <node_id> is the unique identifier of the data node.
+
+Example:
+We have two nodes:
+  node_id: xyz
+  file_name: llama.pdf
+  
+  node_id: abc
+  file_name: animal.pdf
+
+User question: Tell me a fun fact about Llama.
+Your answer:
+A baby llama is called "Cria" [citation:xyz]().
+It often live in desert [citation:abc]().
+It\\'s cute animal.
+'`;
+    systemPromptEnv.push({
+      name: "SYSTEM_CITATION_PROMPT",
+      description:
+        "An additional system prompt to add citation when responding to user questions.",
+      value: citationPrompt,
+    });
+  }
+
+  return systemPromptEnv;
+};
+
+const getTemplateEnvs = (template?: TemplateType): EnvVar[] => {
+  const nextQuestionEnvs: EnvVar[] = [
+    {
+      name: "NEXT_QUESTION_PROMPT",
+      description: `Customize prompt to generate the next question suggestions based on the conversation history.
+Disable this prompt to disable the next question suggestions feature.`,
+      value: `"You're a helpful assistant! Your task is to suggest the next question that user might ask. 
+Here is the conversation history
+---------------------
+{conversation}
+---------------------
+Given the conversation history, please give me 3 questions that user might ask next!
+Your answer should be wrapped in three sticks which follows the following format:
+\`\`\`
+<question 1>
+<question 2>
+<question 3>
+\`\`\`"`,
+    },
+  ];
+
+  if (template === "multiagent" || template === "streaming") {
+    return nextQuestionEnvs;
+  }
+  return [];
+};
+
+const getObservabilityEnvs = (
+  observability?: TemplateObservability,
+): EnvVar[] => {
+  if (observability === "llamatrace") {
+    return [
+      {
+        name: "PHOENIX_API_KEY",
+        description:
+          "API key for LlamaTrace observability. Retrieve from https://llamatrace.com/login",
+      },
+    ];
+  }
+  return [];
+};
+
 export const createBackendEnvFile = async (
  root: string,
  opts: Pick<
@@ -402,6 +574,8 @@ export const createBackendEnvFile = async (
    | "dataSources"
    | "template"
    | "port"
+    | "tools"
+    | "observability"
    | "useLlamaParse"
  >,
 ) => {
@@ -418,11 +592,45 @@ export const createBackendEnvFile = async (
        ]
      : []),
    ...getVectorDBEnvs(opts.vectorDb, opts.framework, opts.template),
-    ...getFrameworkEnvs(opts.framework, opts.port),
-    ...getModelEnvs(opts.modelConfig),
+    ...getToolEnvs(opts.tools),
+    ...getFrameworkEnvs(opts.framework, opts.template, opts.port),
+    // Add environment variables of each component
+    ...(opts.template === "llamaindexserver"
+      ? [
+          {
+            name: "OPENAI_API_KEY",
+            description: "The OpenAI API key to use.",
+            value: opts.modelConfig.apiKey,
+          },
+        ]
+      : [
+          // don't use this stuff for llama-indexserver
+          ...getModelEnvs(opts.modelConfig),
+          ...getEngineEnvs(),
+          ...getTemplateEnvs(opts.template),
+          ...getObservabilityEnvs(opts.observability),
+          ...getSystemPromptEnv(opts.tools, opts.dataSources, opts.template),
+        ]),
  ];
  // Render and write env file
  const content = renderEnvVar(envVars);
  await fs.writeFile(path.join(root, envFileName), content);
  console.log(`Created '${envFileName}' file. Please check the settings.`);
 };
+
+export const createFrontendEnvFile = async (
+  root: string,
+  opts: {
+    vectorDb?: TemplateVectorDB;
+  },
+) => {
+  const defaultFrontendEnvs = [
+    {
+      name: "NEXT_PUBLIC_USE_LLAMACLOUD",
+      description: "Let's the user change indexes in LlamaCloud projects",
+      value: opts.vectorDb === "llamacloud" ? "true" : "false",
+    },
+  ];
+  const content = renderEnvVar(defaultFrontendEnvs);
+  await fs.writeFile(path.join(root, ".env"), content);
+};
@@ -1,3 +1,4 @@
+/* eslint-disable import/no-extraneous-dependencies */
 import { execSync } from "child_process";
 import fs from "fs";
 import path from "path";
@@ -4,10 +4,15 @@ import path from "path";
 import picocolors, { cyan } from "picocolors";

 import fsExtra from "fs-extra";
-import { createBackendEnvFile } from "./env-variables";
+import { writeLoadersConfig } from "./datasources";
+import { createBackendEnvFile, createFrontendEnvFile } from "./env-variables";
 import { PackageManager } from "./get-pkg-manager";
+import { installLlamapackProject } from "./llama-pack";
 import { makeDir } from "./make-dir";
+import { isHavingPoetryLockFile, tryPoetryRun } from "./poetry";
 import { installPythonTemplate } from "./python";
+import { downloadAndExtractRepo } from "./repo";
+import { ConfigFileType, writeToolsConfig } from "./tools";
 import {
  FileSourceConfig,
  InstallTemplateArgs,
@@ -17,7 +22,6 @@ import {
  TemplateVectorDB,
 } from "./types";
 import { installTSTemplate } from "./typescript";
-import { isHavingUvLockFile, tryUvRun } from "./uv";

 const checkForGenerateScript = (
  modelConfig: ModelConfig,
@@ -52,7 +56,6 @@ const checkForGenerateScript = (
 async function generateContextData(
  framework: TemplateFramework,
  modelConfig: ModelConfig,
-  dataSources: TemplateDataSource[],
  packageManager?: PackageManager,
  vectorDb?: TemplateVectorDB,
  llamaCloudKey?: string,
@@ -61,7 +64,7 @@ async function generateContextData(
  if (packageManager) {
    const runGenerate = `${cyan(
      framework === "fastapi"
-        ? "uv run generate"
+        ? "poetry run generate"
        : `${packageManager} run generate`,
    )}`;

@@ -75,30 +78,19 @@ async function generateContextData(
    if (!missingSettings.length) {
      // If all the required environment variables are set, run the generate script
      if (framework === "fastapi") {
-        if (isHavingUvLockFile()) {
+        if (isHavingPoetryLockFile()) {
          console.log(`Running ${runGenerate} to generate the context data.`);
-          const result = tryUvRun("generate");
+          const result = tryPoetryRun("poetry run generate");
          if (!result) {
            console.log(`Failed to run ${runGenerate}.`);
            process.exit(1);
          }
          console.log(`Generated context data`);
          return;
-        } else {
-          console.log(
-            picocolors.yellow(
-              `\nWarning: uv.lock not found. Dependency installation might be incomplete. Skipping context generation.\nIf dependencies were installed, try running '${runGenerate}' manually.\n`,
-            ),
-          );
        }
      } else {
        console.log(`Running ${runGenerate} to generate the context data.`);
-
-        const shouldRunGenerate = dataSources.length > 0;
-
-        if (shouldRunGenerate) {
-          await callPackageManager(packageManager, true, ["run", "generate"]);
-        }
+        await callPackageManager(packageManager, true, ["run", "generate"]);
        return;
      }
    }
@@ -111,7 +103,7 @@ async function generateContextData(
 const downloadFile = async (url: string, destPath: string) => {
  const response = await fetch(url);
  const fileBuffer = await response.arrayBuffer();
-  await fsExtra.writeFile(destPath, new Uint8Array(fileBuffer));
+  await fsExtra.writeFile(destPath, Buffer.from(fileBuffer));
 };

 const prepareContextData = async (
@@ -147,46 +139,98 @@ const prepareContextData = async (
  }
 };

-export const installTemplate = async (props: InstallTemplateArgs) => {
+const installCommunityProject = async ({
+  root,
+  communityProjectConfig,
+}: Pick<InstallTemplateArgs, "root" | "communityProjectConfig">) => {
+  const { owner, repo, branch, filePath } = communityProjectConfig!;
+  console.log("\nInstalling community project:", filePath || repo);
+  await downloadAndExtractRepo(root, {
+    username: owner,
+    name: repo,
+    branch,
+    filePath: filePath || "",
+  });
+};
+
+export const installTemplate = async (
+  props: InstallTemplateArgs & { backend: boolean },
+) => {
  process.chdir(props.root);

+  if (props.template === "community" && props.communityProjectConfig) {
+    await installCommunityProject(props);
+    return;
+  }
+
+  if (props.template === "llamapack" && props.llamapack) {
+    await installLlamapackProject(props);
+    return;
+  }
+
  if (props.framework === "fastapi") {
    await installPythonTemplate(props);
  } else {
    await installTSTemplate(props);
  }

-  // This is a backend, so we need to copy the test data and create the env file.
-
-  // Copy the environment file to the target directory.
-  await createBackendEnvFile(props.root, props);
-
-  await prepareContextData(
-    props.root,
-    props.dataSources.filter((ds) => ds.type === "file"),
-  );
-
-  if (
-    props.dataSources.length > 0 &&
-    (props.postInstallAction === "runApp" ||
-      props.postInstallAction === "dependencies")
-  ) {
-    console.log("\nGenerating context data...\n");
-    await generateContextData(
-      props.framework,
-      props.modelConfig,
-      props.dataSources,
-      props.packageManager,
-      props.vectorDb,
-      props.llamaCloudKey,
-      props.useLlamaParse,
+  // write configurations
+  if (props.template !== "llamaindexserver") {
+    await writeToolsConfig(
+      props.root,
+      props.tools,
+      props.framework === "fastapi" ? ConfigFileType.YAML : ConfigFileType.JSON,
    );
+    if (props.vectorDb !== "llamacloud") {
+      // write loaders configuration (currently Python only)
+      // not needed for LlamaCloud as it has its own loaders
+      await writeLoadersConfig(
+        props.root,
+        props.dataSources,
+        props.useLlamaParse,
+      );
+    }
  }

-  // Create outputs directory
-  await makeDir(path.join(props.root, "output/tools"));
-  await makeDir(path.join(props.root, "output/uploaded"));
-  await makeDir(path.join(props.root, "output/llamacloud"));
+  if (props.backend) {
+    // This is a backend, so we need to copy the test data and create the env file.
+
+    // Copy the environment file to the target directory.
+    if (props.template !== "community" && props.template !== "llamapack") {
+      await createBackendEnvFile(props.root, props);
+    }
+
+    await prepareContextData(
+      props.root,
+      props.dataSources.filter((ds) => ds.type === "file"),
+    );
+
+    if (
+      props.dataSources.length > 0 &&
+      (props.postInstallAction === "runApp" ||
+        props.postInstallAction === "dependencies")
+    ) {
+      console.log("\nGenerating context data...\n");
+      await generateContextData(
+        props.framework,
+        props.modelConfig,
+        props.packageManager,
+        props.vectorDb,
+        props.llamaCloudKey,
+        props.useLlamaParse,
+      );
+    }
+
+    // Create outputs directory
+    await makeDir(path.join(props.root, "output/tools"));
+    await makeDir(path.join(props.root, "output/uploaded"));
+    await makeDir(path.join(props.root, "output/llamacloud"));
+  } else {
+    // this is a frontend for a full-stack app, create .env file with model information
+    await createFrontendEnvFile(props.root, {
+      vectorDb: props.vectorDb,
+    });
+  }
 };

 export * from "./types";
@@ -1,3 +1,4 @@
+/* eslint-disable import/no-extraneous-dependencies */
 import spawn from "cross-spawn";
 import { yellow } from "picocolors";
 import type { PackageManager } from "./get-pkg-manager";
@@ -1,3 +1,4 @@
+/* eslint-disable import/no-extraneous-dependencies */
 import fs from "fs";
 import path from "path";
 import { blue, green } from "picocolors";
@@ -0,0 +1,148 @@
+import fs from "fs/promises";
+import got from "got";
+import path from "path";
+import { parse } from "smol-toml";
+import {
+  LLAMA_PACK_FOLDER,
+  LLAMA_PACK_FOLDER_PATH,
+  LLAMA_PACK_OWNER,
+  LLAMA_PACK_REPO,
+} from "./constant";
+import { copy } from "./copy";
+import { templatesDir } from "./dir";
+import { addDependencies, installPythonDependencies } from "./python";
+import { getRepoRawContent } from "./repo";
+import { InstallTemplateArgs } from "./types";
+
+const getLlamaPackFolderSHA = async () => {
+  const url = `https://api.github.com/repos/${LLAMA_PACK_OWNER}/${LLAMA_PACK_REPO}/contents`;
+  const response = await got(url, {
+    responseType: "json",
+  });
+  const data = response.body as any[];
+  const llamaPackFolder = data.find((item) => item.name === LLAMA_PACK_FOLDER);
+  return llamaPackFolder.sha;
+};
+
+const getLLamaPackFolderTree = async (
+  sha: string,
+): Promise<
+  Array<{
+    path: string;
+  }>
+> => {
+  const url = `https://api.github.com/repos/${LLAMA_PACK_OWNER}/${LLAMA_PACK_REPO}/git/trees/${sha}?recursive=1`;
+  const response = await got(url, {
+    responseType: "json",
+  });
+  return (response.body as any).tree;
+};
+
+export async function getAvailableLlamapackOptions(): Promise<
+  {
+    name: string;
+    folderPath: string;
+  }[]
+> {
+  const EXAMPLE_RELATIVE_PATH = "/examples/example.py";
+  const PACK_FOLDER_SUBFIX = "llama-index-packs";
+
+  const llamaPackFolderSHA = await getLlamaPackFolderSHA();
+  const llamaPackTree = await getLLamaPackFolderTree(llamaPackFolderSHA);
+
+  // Return options that have example files
+  const exampleFiles = llamaPackTree.filter((item) =>
+    item.path.endsWith(EXAMPLE_RELATIVE_PATH),
+  );
+  const options = exampleFiles.map((file) => {
+    const packFolder = file.path.substring(
+      0,
+      file.path.indexOf(EXAMPLE_RELATIVE_PATH),
+    );
+    const packName = packFolder.substring(PACK_FOLDER_SUBFIX.length + 1);
+    return {
+      name: packName,
+      folderPath: packFolder,
+    };
+  });
+  return options;
+}
+
+const copyLlamapackEmptyProject = async ({
+  root,
+}: Pick<InstallTemplateArgs, "root">) => {
+  const templatePath = path.join(
+    templatesDir,
+    "components/sample-projects/llamapack",
+  );
+  await copy("**", root, {
+    parents: true,
+    cwd: templatePath,
+  });
+};
+
+const copyData = async ({
+  root,
+}: Pick<InstallTemplateArgs, "root" | "llamapack">) => {
+  const dataPath = path.join(templatesDir, "components/data");
+  await copy("**", path.join(root, "data"), {
+    parents: true,
+    cwd: dataPath,
+  });
+};
+
+const installLlamapackExample = async ({
+  root,
+  llamapack,
+}: Pick<InstallTemplateArgs, "root" | "llamapack">) => {
+  const exampleFileName = "example.py";
+  const readmeFileName = "README.md";
+  const projectTomlFileName = "pyproject.toml";
+  const exampleFilePath = `${LLAMA_PACK_FOLDER_PATH}/${llamapack}/examples/${exampleFileName}`;
+  const readmeFilePath = `${LLAMA_PACK_FOLDER_PATH}/${llamapack}/${readmeFileName}`;
+  const projectTomlFilePath = `${LLAMA_PACK_FOLDER_PATH}/${llamapack}/${projectTomlFileName}`;
+
+  // Download example.py from llamapack and save to root
+  const exampleContent = await getRepoRawContent(exampleFilePath);
+  await fs.writeFile(path.join(root, exampleFileName), exampleContent);
+
+  // Download README.md from llamapack and combine with README-template.md,
+  // save to root and then delete template file
+  const readmeContent = await getRepoRawContent(readmeFilePath);
+  const readmeTemplateContent = await fs.readFile(
+    path.join(root, "README-template.md"),
+    "utf-8",
+  );
+  await fs.writeFile(
+    path.join(root, readmeFileName),
+    `${readmeContent}\n${readmeTemplateContent}`,
+  );
+  await fs.unlink(path.join(root, "README-template.md"));
+
+  // Download pyproject.toml from llamapack, parse it to get package name and version,
+  // then add it as a dependency to current toml file in the project
+  const projectTomlContent = await getRepoRawContent(projectTomlFilePath);
+  const fileParsed = parse(projectTomlContent) as any;
+  const packageName = fileParsed.tool.poetry.name;
+  const packageVersion = fileParsed.tool.poetry.version;
+  await addDependencies(root, [
+    {
+      name: packageName,
+      version: packageVersion,
+    },
+  ]);
+};
+
+export const installLlamapackProject = async ({
+  root,
+  llamapack,
+  postInstallAction,
+}: Pick<InstallTemplateArgs, "root" | "llamapack" | "postInstallAction">) => {
+  console.log("\nInstalling Llamapack project:", llamapack!);
+  await copyLlamapackEmptyProject({ root });
+  await copyData({ root });
+  await installLlamapackExample({ root, llamapack });
+  if (postInstallAction === "runApp" || postInstallAction === "dependencies") {
+    installPythonDependencies({ noRoot: true });
+  }
+};
@@ -0,0 +1,36 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { execSync } from "child_process";
+import fs from "fs";
+
+export function isPoetryAvailable(): boolean {
+  try {
+    execSync("poetry --version", { stdio: "ignore" });
+    return true;
+  } catch (_) {}
+  return false;
+}
+
+export function tryPoetryInstall(noRoot: boolean): boolean {
+  try {
+    execSync(`poetry install${noRoot ? " --no-root" : ""}`, {
+      stdio: "inherit",
+    });
+    return true;
+  } catch (_) {}
+  return false;
+}
+
+export function tryPoetryRun(command: string): boolean {
+  try {
+    execSync(`poetry run ${command}`, { stdio: "inherit" });
+    return true;
+  } catch (_) {}
+  return false;
+}
+
+export function isHavingPoetryLockFile(): boolean {
+  try {
+    return fs.existsSync("poetry.lock");
+  } catch (_) {}
+  return false;
+}
@@ -31,9 +31,17 @@ const EMBEDDING_MODELS: Record<HuggingFaceEmbeddingModelType, ModelData> = {
 const DEFAULT_EMBEDDING_MODEL = Object.keys(EMBEDDING_MODELS)[0];
 const DEFAULT_DIMENSIONS = Object.values(EMBEDDING_MODELS)[0].dimensions;

-export async function askAnthropicQuestions(): Promise<ModelConfigParams> {
+type AnthropicQuestionsParams = {
+  apiKey?: string;
+  askModels: boolean;
+};
+
+export async function askAnthropicQuestions({
+  askModels,
+  apiKey,
+}: AnthropicQuestionsParams): Promise<ModelConfigParams> {
  const config: ModelConfigParams = {
-    apiKey: process.env.ANTHROPIC_API_KEY,
+    apiKey,
    model: DEFAULT_MODEL,
    embeddingModel: DEFAULT_EMBEDDING_MODEL,
    dimensions: DEFAULT_DIMENSIONS,
@@ -61,33 +69,35 @@ export async function askAnthropicQuestions(): Promise<ModelConfigParams> {
    config.apiKey = key || process.env.ANTHROPIC_API_KEY;
  }

-  const { model } = await prompts(
-    {
-      type: "select",
-      name: "model",
-      message: "Which LLM model would you like to use?",
-      choices: MODELS.map(toChoice),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.model = model;
+  if (askModels) {
+    const { model } = await prompts(
+      {
+        type: "select",
+        name: "model",
+        message: "Which LLM model would you like to use?",
+        choices: MODELS.map(toChoice),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.model = model;

-  const { embeddingModel } = await prompts(
-    {
-      type: "select",
-      name: "embeddingModel",
-      message: "Which embedding model would you like to use?",
-      choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.embeddingModel = embeddingModel;
-  config.dimensions =
-    EMBEDDING_MODELS[
-      embeddingModel as HuggingFaceEmbeddingModelType
-    ].dimensions;
+    const { embeddingModel } = await prompts(
+      {
+        type: "select",
+        name: "embeddingModel",
+        message: "Which embedding model would you like to use?",
+        choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.embeddingModel = embeddingModel;
+    config.dimensions =
+      EMBEDDING_MODELS[
+        embeddingModel as HuggingFaceEmbeddingModelType
+      ].dimensions;
+  }

  return config;
 }
@@ -1,5 +1,5 @@
 import prompts from "prompts";
-import { ModelConfigParams } from ".";
+import { ModelConfigParams, ModelConfigQuestionsParams } from ".";
 import { questionHandlers } from "../../questions/utils";

 const ALL_AZURE_OPENAI_CHAT_MODELS: Record<string, { openAIModel: string }> = {
@@ -51,9 +51,12 @@ const ALL_AZURE_OPENAI_EMBEDDING_MODELS: Record<
 const DEFAULT_MODEL = "gpt-4o";
 const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-large";

-export async function askAzureQuestions(): Promise<ModelConfigParams> {
+export async function askAzureQuestions({
+  openAiKey,
+  askModels,
+}: ModelConfigQuestionsParams): Promise<ModelConfigParams> {
  const config: ModelConfigParams = {
-    apiKey: process.env.AZURE_OPENAI_KEY,
+    apiKey: openAiKey || process.env.AZURE_OPENAI_KEY,
    model: DEFAULT_MODEL,
    embeddingModel: DEFAULT_EMBEDDING_MODEL,
    dimensions: getDimensions(DEFAULT_EMBEDDING_MODEL),
@@ -63,30 +66,32 @@ export async function askAzureQuestions(): Promise<ModelConfigParams> {
    },
  };

-  const { model } = await prompts(
-    {
-      type: "select",
-      name: "model",
-      message: "Which LLM model would you like to use?",
-      choices: getAvailableModelChoices(),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.model = model;
+  if (askModels) {
+    const { model } = await prompts(
+      {
+        type: "select",
+        name: "model",
+        message: "Which LLM model would you like to use?",
+        choices: getAvailableModelChoices(),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.model = model;

-  const { embeddingModel } = await prompts(
-    {
-      type: "select",
-      name: "embeddingModel",
-      message: "Which embedding model would you like to use?",
-      choices: getAvailableEmbeddingModelChoices(),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.embeddingModel = embeddingModel;
-  config.dimensions = getDimensions(embeddingModel);
+    const { embeddingModel } = await prompts(
+      {
+        type: "select",
+        name: "embeddingModel",
+        message: "Which embedding model would you like to use?",
+        choices: getAvailableEmbeddingModelChoices(),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.embeddingModel = embeddingModel;
+    config.dimensions = getDimensions(embeddingModel);
+  }

  return config;
 }
@@ -2,15 +2,7 @@ import prompts from "prompts";
 import { ModelConfigParams } from ".";
 import { questionHandlers, toChoice } from "../../questions/utils";

-const MODELS = [
-  "gemini-2.5-pro",
-  "gemini-2.5-flash",
-  "gemini-2.0-flash",
-  "gemini-2.0-flash-lite",
-  "gemini-1.5-pro-latest",
-  "gemini-pro",
-  "gemini-pro-vision",
-];
+const MODELS = ["gemini-1.5-pro-latest", "gemini-pro", "gemini-pro-vision"];
 type ModelData = {
  dimensions: number;
 };
@@ -23,9 +15,17 @@ const DEFAULT_MODEL = MODELS[0];
 const DEFAULT_EMBEDDING_MODEL = Object.keys(EMBEDDING_MODELS)[0];
 const DEFAULT_DIMENSIONS = Object.values(EMBEDDING_MODELS)[0].dimensions;

-export async function askGeminiQuestions(): Promise<ModelConfigParams> {
+type GeminiQuestionsParams = {
+  apiKey?: string;
+  askModels: boolean;
+};
+
+export async function askGeminiQuestions({
+  askModels,
+  apiKey,
+}: GeminiQuestionsParams): Promise<ModelConfigParams> {
  const config: ModelConfigParams = {
-    apiKey: process.env.GOOGLE_API_KEY,
+    apiKey,
    model: DEFAULT_MODEL,
    embeddingModel: DEFAULT_EMBEDDING_MODEL,
    dimensions: DEFAULT_DIMENSIONS,
@@ -53,30 +53,32 @@ export async function askGeminiQuestions(): Promise<ModelConfigParams> {
    config.apiKey = key || process.env.GOOGLE_API_KEY;
  }

-  const { model } = await prompts(
-    {
-      type: "select",
-      name: "model",
-      message: "Which LLM model would you like to use?",
-      choices: MODELS.map(toChoice),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.model = model;
+  if (askModels) {
+    const { model } = await prompts(
+      {
+        type: "select",
+        name: "model",
+        message: "Which LLM model would you like to use?",
+        choices: MODELS.map(toChoice),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.model = model;

-  const { embeddingModel } = await prompts(
-    {
-      type: "select",
-      name: "embeddingModel",
-      message: "Which embedding model would you like to use?",
-      choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.embeddingModel = embeddingModel;
-  config.dimensions = EMBEDDING_MODELS[embeddingModel].dimensions;
+    const { embeddingModel } = await prompts(
+      {
+        type: "select",
+        name: "embeddingModel",
+        message: "Which embedding model would you like to use?",
+        choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.embeddingModel = embeddingModel;
+    config.dimensions = EMBEDDING_MODELS[embeddingModel].dimensions;
+  }

  return config;
 }
@@ -71,9 +71,17 @@ const EMBEDDING_MODELS: Record<HuggingFaceEmbeddingModelType, ModelData> = {
 const DEFAULT_EMBEDDING_MODEL = Object.keys(EMBEDDING_MODELS)[0];
 const DEFAULT_DIMENSIONS = Object.values(EMBEDDING_MODELS)[0].dimensions;

-export async function askGroqQuestions(): Promise<ModelConfigParams> {
+type GroqQuestionsParams = {
+  apiKey?: string;
+  askModels: boolean;
+};
+
+export async function askGroqQuestions({
+  askModels,
+  apiKey,
+}: GroqQuestionsParams): Promise<ModelConfigParams> {
  const config: ModelConfigParams = {
-    apiKey: process.env.GROQ_API_KEY,
+    apiKey,
    model: DEFAULT_MODEL,
    embeddingModel: DEFAULT_EMBEDDING_MODEL,
    dimensions: DEFAULT_DIMENSIONS,
@@ -101,35 +109,37 @@ export async function askGroqQuestions(): Promise<ModelConfigParams> {
    config.apiKey = key || process.env.GROQ_API_KEY;
  }

-  const modelChoices = await getAvailableModelChoicesGroq(config.apiKey!);
+  if (askModels) {
+    const modelChoices = await getAvailableModelChoicesGroq(config.apiKey!);

-  const { model } = await prompts(
-    {
-      type: "select",
-      name: "model",
-      message: "Which LLM model would you like to use?",
-      choices: modelChoices,
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.model = model;
+    const { model } = await prompts(
+      {
+        type: "select",
+        name: "model",
+        message: "Which LLM model would you like to use?",
+        choices: modelChoices,
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.model = model;

-  const { embeddingModel } = await prompts(
-    {
-      type: "select",
-      name: "embeddingModel",
-      message: "Which embedding model would you like to use?",
-      choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.embeddingModel = embeddingModel;
-  config.dimensions =
-    EMBEDDING_MODELS[
-      embeddingModel as HuggingFaceEmbeddingModelType
-    ].dimensions;
+    const { embeddingModel } = await prompts(
+      {
+        type: "select",
+        name: "embeddingModel",
+        message: "Which embedding model would you like to use?",
+        choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.embeddingModel = embeddingModel;
+    config.dimensions =
+      EMBEDDING_MODELS[
+        embeddingModel as HuggingFaceEmbeddingModelType
+      ].dimensions;
+  }

  return config;
 }
@@ -21,7 +21,13 @@ const DEFAULT_MODEL = MODELS[0];
 const DEFAULT_EMBEDDING_MODEL = Object.keys(EMBEDDING_MODELS)[0];
 const DEFAULT_DIMENSIONS = Object.values(EMBEDDING_MODELS)[0].dimensions;

-export async function askHuggingfaceQuestions(): Promise<ModelConfigParams> {
+type HuggingfaceQuestionsParams = {
+  askModels: boolean;
+};
+
+export async function askHuggingfaceQuestions({
+  askModels,
+}: HuggingfaceQuestionsParams): Promise<ModelConfigParams> {
  const config: ModelConfigParams = {
    model: DEFAULT_MODEL,
    embeddingModel: DEFAULT_EMBEDDING_MODEL,
@@ -31,30 +37,32 @@ export async function askHuggingfaceQuestions(): Promise<ModelConfigParams> {
    },
  };

-  const { model } = await prompts(
-    {
-      type: "select",
-      name: "model",
-      message: "Which Hugging Face model would you like to use?",
-      choices: MODELS.map(toChoice),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.model = model;
+  if (askModels) {
+    const { model } = await prompts(
+      {
+        type: "select",
+        name: "model",
+        message: "Which Hugging Face model would you like to use?",
+        choices: MODELS.map(toChoice),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.model = model;

-  const { embeddingModel } = await prompts(
-    {
-      type: "select",
-      name: "embeddingModel",
-      message: "Which embedding model would you like to use?",
-      choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.embeddingModel = embeddingModel;
-  config.dimensions = EMBEDDING_MODELS[embeddingModel].dimensions;
+    const { embeddingModel } = await prompts(
+      {
+        type: "select",
+        name: "embeddingModel",
+        message: "Which embedding model would you like to use?",
+        choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.embeddingModel = embeddingModel;
+    config.dimensions = EMBEDDING_MODELS[embeddingModel].dimensions;
+  }

  return config;
 }
@@ -0,0 +1,94 @@
+import prompts from "prompts";
+import { questionHandlers } from "../../questions/utils";
+import { ModelConfig, ModelProvider, TemplateFramework } from "../types";
+import { askAnthropicQuestions } from "./anthropic";
+import { askAzureQuestions } from "./azure";
+import { askGeminiQuestions } from "./gemini";
+import { askGroqQuestions } from "./groq";
+import { askHuggingfaceQuestions } from "./huggingface";
+import { askLLMHubQuestions } from "./llmhub";
+import { askMistralQuestions } from "./mistral";
+import { askOllamaQuestions } from "./ollama";
+import { askOpenAIQuestions } from "./openai";
+
+const DEFAULT_MODEL_PROVIDER = "openai";
+
+export type ModelConfigQuestionsParams = {
+  openAiKey?: string;
+  askModels: boolean;
+  framework?: TemplateFramework;
+};
+
+export type ModelConfigParams = Omit<ModelConfig, "provider">;
+
+export async function askModelConfig({
+  askModels,
+  openAiKey,
+  framework,
+}: ModelConfigQuestionsParams): Promise<ModelConfig> {
+  let modelProvider: ModelProvider = DEFAULT_MODEL_PROVIDER;
+  if (askModels) {
+    let choices = [
+      { title: "OpenAI", value: "openai" },
+      { title: "Groq", value: "groq" },
+      { title: "Ollama", value: "ollama" },
+      { title: "Anthropic", value: "anthropic" },
+      { title: "Gemini", value: "gemini" },
+      { title: "Mistral", value: "mistral" },
+      { title: "AzureOpenAI", value: "azure-openai" },
+    ];
+
+    if (framework === "fastapi") {
+      choices.push({ title: "T-Systems", value: "t-systems" });
+      choices.push({ title: "Huggingface", value: "huggingface" });
+    }
+    const { provider } = await prompts(
+      {
+        type: "select",
+        name: "provider",
+        message: "Which model provider would you like to use",
+        choices: choices,
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    modelProvider = provider;
+  }
+
+  let modelConfig: ModelConfigParams;
+  switch (modelProvider) {
+    case "ollama":
+      modelConfig = await askOllamaQuestions({ askModels });
+      break;
+    case "groq":
+      modelConfig = await askGroqQuestions({ askModels });
+      break;
+    case "anthropic":
+      modelConfig = await askAnthropicQuestions({ askModels });
+      break;
+    case "gemini":
+      modelConfig = await askGeminiQuestions({ askModels });
+      break;
+    case "mistral":
+      modelConfig = await askMistralQuestions({ askModels });
+      break;
+    case "azure-openai":
+      modelConfig = await askAzureQuestions({ askModels });
+      break;
+    case "t-systems":
+      modelConfig = await askLLMHubQuestions({ askModels });
+      break;
+    case "huggingface":
+      modelConfig = await askHuggingfaceQuestions({ askModels });
+      break;
+    default:
+      modelConfig = await askOpenAIQuestions({
+        openAiKey,
+        askModels,
+      });
+  }
+  return {
+    ...modelConfig,
+    provider: modelProvider,
+  };
+}
@@ -31,9 +31,17 @@ const LLMHUB_EMBEDDING_MODELS = [
  "text-embedding-bge-m3",
 ];

-export async function askLLMHubQuestions(): Promise<ModelConfigParams> {
+type LLMHubQuestionsParams = {
+  apiKey?: string;
+  askModels: boolean;
+};
+
+export async function askLLMHubQuestions({
+  askModels,
+  apiKey,
+}: LLMHubQuestionsParams): Promise<ModelConfigParams> {
  const config: ModelConfigParams = {
-    apiKey: process.env.T_SYSTEMS_LLMHUB_API_KEY,
+    apiKey,
    model: DEFAULT_MODEL,
    embeddingModel: DEFAULT_EMBEDDING_MODEL,
    dimensions: getDimensions(DEFAULT_EMBEDDING_MODEL),
@@ -53,10 +61,11 @@ export async function askLLMHubQuestions(): Promise<ModelConfigParams> {
      {
        type: "text",
        name: "key",
-        message:
-          "Please provide your LLMHub API key (or leave blank to use T_SYSTEMS_LLMHUB_API_KEY env variable):",
+        message: askModels
+          ? "Please provide your LLMHub API key (or leave blank to use T_SYSTEMS_LLMHUB_API_KEY env variable):"
+          : "Please provide your LLMHub API key (leave blank to skip):",
        validate: (value: string) => {
-          if (!value) {
+          if (askModels && !value) {
            if (process.env.T_SYSTEMS_LLMHUB_API_KEY) {
              return true;
            }
@@ -70,30 +79,32 @@ export async function askLLMHubQuestions(): Promise<ModelConfigParams> {
    config.apiKey = key || process.env.T_SYSTEMS_LLMHUB_API_KEY;
  }

-  const { model } = await prompts(
-    {
-      type: "select",
-      name: "model",
-      message: "Which LLM model would you like to use?",
-      choices: await getAvailableModelChoices(false, config.apiKey),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.model = model;
+  if (askModels) {
+    const { model } = await prompts(
+      {
+        type: "select",
+        name: "model",
+        message: "Which LLM model would you like to use?",
+        choices: await getAvailableModelChoices(false, config.apiKey),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.model = model;

-  const { embeddingModel } = await prompts(
-    {
-      type: "select",
-      name: "embeddingModel",
-      message: "Which embedding model would you like to use?",
-      choices: await getAvailableModelChoices(true, config.apiKey),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.embeddingModel = embeddingModel;
-  config.dimensions = getDimensions(embeddingModel);
+    const { embeddingModel } = await prompts(
+      {
+        type: "select",
+        name: "embeddingModel",
+        message: "Which embedding model would you like to use?",
+        choices: await getAvailableModelChoices(true, config.apiKey),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.embeddingModel = embeddingModel;
+    config.dimensions = getDimensions(embeddingModel);
+  }

  return config;
 }
@@ -14,9 +14,17 @@ const DEFAULT_MODEL = MODELS[0];
 const DEFAULT_EMBEDDING_MODEL = Object.keys(EMBEDDING_MODELS)[0];
 const DEFAULT_DIMENSIONS = Object.values(EMBEDDING_MODELS)[0].dimensions;

-export async function askMistralQuestions(): Promise<ModelConfigParams> {
+type MistralQuestionsParams = {
+  apiKey?: string;
+  askModels: boolean;
+};
+
+export async function askMistralQuestions({
+  askModels,
+  apiKey,
+}: MistralQuestionsParams): Promise<ModelConfigParams> {
  const config: ModelConfigParams = {
-    apiKey: process.env.MISTRAL_API_KEY,
+    apiKey,
    model: DEFAULT_MODEL,
    embeddingModel: DEFAULT_EMBEDDING_MODEL,
    dimensions: DEFAULT_DIMENSIONS,
@@ -44,30 +52,32 @@ export async function askMistralQuestions(): Promise<ModelConfigParams> {
    config.apiKey = key || process.env.MISTRAL_API_KEY;
  }

-  const { model } = await prompts(
-    {
-      type: "select",
-      name: "model",
-      message: "Which LLM model would you like to use?",
-      choices: MODELS.map(toChoice),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.model = model;
+  if (askModels) {
+    const { model } = await prompts(
+      {
+        type: "select",
+        name: "model",
+        message: "Which LLM model would you like to use?",
+        choices: MODELS.map(toChoice),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.model = model;

-  const { embeddingModel } = await prompts(
-    {
-      type: "select",
-      name: "embeddingModel",
-      message: "Which embedding model would you like to use?",
-      choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.embeddingModel = embeddingModel;
-  config.dimensions = EMBEDDING_MODELS[embeddingModel].dimensions;
+    const { embeddingModel } = await prompts(
+      {
+        type: "select",
+        name: "embeddingModel",
+        message: "Which embedding model would you like to use?",
+        choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.embeddingModel = embeddingModel;
+    config.dimensions = EMBEDDING_MODELS[embeddingModel].dimensions;
+  }

  return config;
 }
@@ -17,7 +17,13 @@ const EMBEDDING_MODELS: Record<string, ModelData> = {
 };
 const DEFAULT_EMBEDDING_MODEL: string = Object.keys(EMBEDDING_MODELS)[0];

-export async function askOllamaQuestions(): Promise<ModelConfigParams> {
+type OllamaQuestionsParams = {
+  askModels: boolean;
+};
+
+export async function askOllamaQuestions({
+  askModels,
+}: OllamaQuestionsParams): Promise<ModelConfigParams> {
  const config: ModelConfigParams = {
    model: DEFAULT_MODEL,
    embeddingModel: DEFAULT_EMBEDDING_MODEL,
@@ -27,32 +33,34 @@ export async function askOllamaQuestions(): Promise<ModelConfigParams> {
    },
  };

-  const { model } = await prompts(
-    {
-      type: "select",
-      name: "model",
-      message: "Which LLM model would you like to use?",
-      choices: MODELS.map(toChoice),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  await ensureModel(model);
-  config.model = model;
+  if (askModels) {
+    const { model } = await prompts(
+      {
+        type: "select",
+        name: "model",
+        message: "Which LLM model would you like to use?",
+        choices: MODELS.map(toChoice),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    await ensureModel(model);
+    config.model = model;

-  const { embeddingModel } = await prompts(
-    {
-      type: "select",
-      name: "embeddingModel",
-      message: "Which embedding model would you like to use?",
-      choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  await ensureModel(embeddingModel);
-  config.embeddingModel = embeddingModel;
-  config.dimensions = EMBEDDING_MODELS[embeddingModel].dimensions;
+    const { embeddingModel } = await prompts(
+      {
+        type: "select",
+        name: "embeddingModel",
+        message: "Which embedding model would you like to use?",
+        choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    await ensureModel(embeddingModel);
+    config.embeddingModel = embeddingModel;
+    config.dimensions = EMBEDDING_MODELS[embeddingModel].dimensions;
+  }

  return config;
 }
@@ -2,7 +2,8 @@ import got from "got";
 import ora from "ora";
 import { red } from "picocolors";
 import prompts from "prompts";
-import { ModelConfigParams } from ".";
+import { ModelConfigParams, ModelConfigQuestionsParams } from ".";
+import { isCI } from "../../questions";
 import { questionHandlers } from "../../questions/utils";

 const OPENAI_API_URL = "https://api.openai.com/v1";
@@ -10,9 +11,12 @@ const OPENAI_API_URL = "https://api.openai.com/v1";
 const DEFAULT_MODEL = "gpt-4o-mini";
 const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-large";

-export async function askOpenAIQuestions(): Promise<ModelConfigParams> {
+export async function askOpenAIQuestions({
+  openAiKey,
+  askModels,
+}: ModelConfigQuestionsParams): Promise<ModelConfigParams> {
  const config: ModelConfigParams = {
-    apiKey: process.env.OPENAI_API_KEY,
+    apiKey: openAiKey,
    model: DEFAULT_MODEL,
    embeddingModel: DEFAULT_EMBEDDING_MODEL,
    dimensions: getDimensions(DEFAULT_EMBEDDING_MODEL),
@@ -27,15 +31,16 @@ export async function askOpenAIQuestions(): Promise<ModelConfigParams> {
    },
  };

-  if (!config.apiKey) {
+  if (!config.apiKey && !isCI) {
    const { key } = await prompts(
      {
        type: "text",
        name: "key",
-        message:
-          "Please provide your OpenAI API key (or leave blank to use OPENAI_API_KEY env variable):",
+        message: askModels
+          ? "Please provide your OpenAI API key (or leave blank to use OPENAI_API_KEY env variable):"
+          : "Please provide your OpenAI API key (leave blank to skip):",
        validate: (value: string) => {
-          if (!value) {
+          if (askModels && !value) {
            if (process.env.OPENAI_API_KEY) {
              return true;
            }
@@ -49,30 +54,32 @@ export async function askOpenAIQuestions(): Promise<ModelConfigParams> {
    config.apiKey = key || process.env.OPENAI_API_KEY;
  }

-  const { model } = await prompts(
-    {
-      type: "select",
-      name: "model",
-      message: "Which LLM model would you like to use?",
-      choices: await getAvailableModelChoices(false, config.apiKey),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.model = model;
+  if (askModels) {
+    const { model } = await prompts(
+      {
+        type: "select",
+        name: "model",
+        message: "Which LLM model would you like to use?",
+        choices: await getAvailableModelChoices(false, config.apiKey),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.model = model;

-  const { embeddingModel } = await prompts(
-    {
-      type: "select",
-      name: "embeddingModel",
-      message: "Which embedding model would you like to use?",
-      choices: await getAvailableModelChoices(true, config.apiKey),
-      initial: 0,
-    },
-    questionHandlers,
-  );
-  config.embeddingModel = embeddingModel;
-  config.dimensions = getDimensions(embeddingModel);
+    const { embeddingModel } = await prompts(
+      {
+        type: "select",
+        name: "embeddingModel",
+        message: "Which embedding model would you like to use?",
+        choices: await getAvailableModelChoices(true, config.apiKey),
+        initial: 0,
+      },
+      questionHandlers,
+    );
+    config.embeddingModel = embeddingModel;
+    config.dimensions = getDimensions(embeddingModel);
+  }

  return config;
 }
@@ -0,0 +1,651 @@
+import fs from "fs/promises";
+import path from "path";
+import { cyan, red } from "picocolors";
+import { parse, stringify } from "smol-toml";
+import terminalLink from "terminal-link";
+
+import { assetRelocator, copy } from "./copy";
+import { templatesDir } from "./dir";
+import { isPoetryAvailable, tryPoetryInstall } from "./poetry";
+import { Tool } from "./tools";
+import {
+  InstallTemplateArgs,
+  ModelConfig,
+  TemplateDataSource,
+  TemplateObservability,
+  TemplateType,
+  TemplateVectorDB,
+} from "./types";
+
+interface Dependency {
+  name: string;
+  version?: string;
+  extras?: string[];
+  constraints?: Record<string, string>;
+}
+
+const getAdditionalDependencies = (
+  modelConfig: ModelConfig,
+  vectorDb?: TemplateVectorDB,
+  dataSources?: TemplateDataSource[],
+  tools?: Tool[],
+  templateType?: TemplateType,
+  observability?: TemplateObservability,
+) => {
+  const dependencies: Dependency[] = [];
+
+  // Add vector db dependencies
+  switch (vectorDb) {
+    case "mongo": {
+      dependencies.push({
+        name: "llama-index-vector-stores-mongodb",
+        version: "^0.6.0",
+      });
+      break;
+    }
+    case "pg": {
+      dependencies.push({
+        name: "llama-index-vector-stores-postgres",
+        version: "^0.3.2",
+      });
+      break;
+    }
+    case "pinecone": {
+      dependencies.push({
+        name: "llama-index-vector-stores-pinecone",
+        version: "^0.4.1",
+        constraints: {
+          python: ">=3.11,<3.13",
+        },
+      });
+      break;
+    }
+    case "milvus": {
+      dependencies.push({
+        name: "llama-index-vector-stores-milvus",
+        version: "^0.3.0",
+      });
+      dependencies.push({
+        name: "pymilvus",
+        version: "2.4.4",
+      });
+      break;
+    }
+    case "astra": {
+      dependencies.push({
+        name: "llama-index-vector-stores-astra-db",
+        version: "^0.4.0",
+      });
+      break;
+    }
+    case "qdrant": {
+      dependencies.push({
+        name: "llama-index-vector-stores-qdrant",
+        version: "^0.4.0",
+        constraints: {
+          python: ">=3.11,<3.13",
+        },
+      });
+      break;
+    }
+    case "chroma": {
+      dependencies.push({
+        name: "llama-index-vector-stores-chroma",
+        version: "^0.4.0",
+      });
+      break;
+    }
+    case "weaviate": {
+      dependencies.push({
+        name: "llama-index-vector-stores-weaviate",
+        version: "^1.2.3",
+      });
+      break;
+    }
+    case "llamacloud":
+      dependencies.push({
+        name: "llama-index-indices-managed-llama-cloud",
+        version: "0.6.3",
+      });
+      break;
+  }
+
+  // Add data source dependencies
+  if (dataSources) {
+    for (const ds of dataSources) {
+      const dsType = ds?.type;
+      switch (dsType) {
+        case "file":
+          dependencies.push({
+            name: "docx2txt",
+            version: "^0.8",
+          });
+          break;
+        case "web":
+          dependencies.push({
+            name: "llama-index-readers-web",
+            version: "^0.3.0",
+          });
+          break;
+        case "db":
+          dependencies.push({
+            name: "llama-index-readers-database",
+            version: "^0.3.0",
+          });
+          dependencies.push({
+            name: "pymysql",
+            version: "^1.1.0",
+            extras: ["rsa"],
+          });
+          dependencies.push({
+            name: "psycopg2-binary",
+            version: "^2.9.9",
+          });
+          break;
+      }
+    }
+  }
+
+  // Add tools dependencies
+  console.log("Adding tools dependencies");
+  tools?.forEach((tool) => {
+    tool.dependencies?.forEach((dep) => {
+      dependencies.push(dep);
+    });
+  });
+
+  switch (modelConfig.provider) {
+    case "ollama":
+      dependencies.push({
+        name: "llama-index-llms-ollama",
+        version: "0.3.0",
+      });
+      dependencies.push({
+        name: "llama-index-embeddings-ollama",
+        version: "0.3.0",
+      });
+      break;
+    case "openai":
+      if (templateType !== "multiagent") {
+        dependencies.push({
+          name: "llama-index-llms-openai",
+          version: "^0.3.2",
+        });
+        dependencies.push({
+          name: "llama-index-embeddings-openai",
+          version: "^0.3.1",
+        });
+        dependencies.push({
+          name: "llama-index-agent-openai",
+          version: "^0.4.0",
+        });
+      }
+      break;
+    case "groq":
+      // Fastembed==0.2.0 does not support python3.13 at the moment
+      // Fixed the python version less than 3.13
+      dependencies.push({
+        name: "python",
+        version: "^3.11,<3.13",
+      });
+      dependencies.push({
+        name: "llama-index-llms-groq",
+        version: "0.2.0",
+      });
+      dependencies.push({
+        name: "llama-index-embeddings-fastembed",
+        version: "^0.2.0",
+      });
+      break;
+    case "anthropic":
+      // Fastembed==0.2.0 does not support python3.13 at the moment
+      // Fixed the python version less than 3.13
+      dependencies.push({
+        name: "python",
+        version: "^3.11,<3.13",
+      });
+      dependencies.push({
+        name: "llama-index-llms-anthropic",
+        version: "0.3.0",
+      });
+      dependencies.push({
+        name: "llama-index-embeddings-fastembed",
+        version: "^0.2.0",
+      });
+      break;
+    case "gemini":
+      dependencies.push({
+        name: "llama-index-llms-gemini",
+        version: "0.3.4",
+      });
+      dependencies.push({
+        name: "llama-index-embeddings-gemini",
+        version: "^0.2.0",
+      });
+      break;
+    case "mistral":
+      dependencies.push({
+        name: "llama-index-llms-mistralai",
+        version: "0.2.1",
+      });
+      dependencies.push({
+        name: "llama-index-embeddings-mistralai",
+        version: "0.2.0",
+      });
+      break;
+    case "azure-openai":
+      dependencies.push({
+        name: "llama-index-llms-azure-openai",
+        version: "0.2.0",
+      });
+      dependencies.push({
+        name: "llama-index-embeddings-azure-openai",
+        version: "0.2.4",
+      });
+      break;
+    case "huggingface":
+      dependencies.push({
+        name: "llama-index-llms-huggingface",
+        version: "^0.3.5",
+      });
+      dependencies.push({
+        name: "llama-index-embeddings-huggingface",
+        version: "^0.3.1",
+      });
+      dependencies.push({
+        name: "optimum",
+        version: "^1.23.3",
+        extras: ["onnxruntime"],
+      });
+      break;
+    case "t-systems":
+      dependencies.push({
+        name: "llama-index-agent-openai",
+        version: "0.3.0",
+      });
+      dependencies.push({
+        name: "llama-index-llms-openai-like",
+        version: "0.2.0",
+      });
+      break;
+  }
+
+  if (observability && observability !== "none") {
+    if (observability === "traceloop") {
+      dependencies.push({
+        name: "traceloop-sdk",
+        version: "^0.15.11",
+      });
+    }
+    if (observability === "llamatrace") {
+      dependencies.push({
+        name: "llama-index-callbacks-arize-phoenix",
+        version: "^0.3.0",
+      });
+    }
+  }
+
+  return dependencies;
+};
+
+const mergePoetryDependencies = (
+  dependencies: Dependency[],
+  existingDependencies: Record<string, Omit<Dependency, "name"> | string>,
+) => {
+  for (const dependency of dependencies) {
+    let value = existingDependencies[dependency.name] ?? {};
+
+    // default string value is equal to attribute "version"
+    if (typeof value === "string") {
+      value = { version: value };
+    }
+
+    value.version = dependency.version ?? value.version;
+    value.extras = dependency.extras ?? value.extras;
+
+    // Merge constraints if they exist
+    if (dependency.constraints) {
+      value = { ...value, ...dependency.constraints };
+    }
+
+    if (value.version === undefined) {
+      throw new Error(
+        `Dependency "${dependency.name}" is missing attribute "version"!`,
+      );
+    }
+
+    // Serialize as object if there are any additional properties
+    if (Object.keys(value).length > 1) {
+      existingDependencies[dependency.name] = value;
+    } else {
+      // Otherwise, serialize just the version string
+      existingDependencies[dependency.name] = value.version;
+    }
+  }
+};
+
+const copyRouterCode = async (root: string, tools: Tool[]) => {
+  // Copy sandbox router if the artifact tool is selected
+  if (tools?.some((t) => t.name === "artifact")) {
+    await copy("sandbox.py", path.join(root, "app", "api", "routers"), {
+      parents: true,
+      cwd: path.join(templatesDir, "components", "routers", "python"),
+      rename: assetRelocator,
+    });
+  }
+};
+
+export const addDependencies = async (
+  projectDir: string,
+  dependencies: Dependency[],
+) => {
+  if (dependencies.length === 0) return;
+
+  const FILENAME = "pyproject.toml";
+  try {
+    // Parse toml file
+    const file = path.join(projectDir, FILENAME);
+    const fileContent = await fs.readFile(file, "utf8");
+    const fileParsed = parse(fileContent);
+
+    // Modify toml dependencies
+    const tool = fileParsed.tool as any;
+    const existingDependencies = tool.poetry.dependencies;
+    mergePoetryDependencies(dependencies, existingDependencies);
+
+    // Write toml file
+    const newFileContent = stringify(fileParsed);
+    await fs.writeFile(file, newFileContent);
+
+    const dependenciesString = dependencies.map((d) => d.name).join(", ");
+    console.log(`\nAdded ${dependenciesString} to ${cyan(FILENAME)}\n`);
+  } catch (error) {
+    console.log(
+      `Error while updating dependencies for Poetry project file ${FILENAME}\n`,
+      error,
+    );
+  }
+};
+
+export const installPythonDependencies = (
+  { noRoot }: { noRoot: boolean } = { noRoot: false },
+) => {
+  if (isPoetryAvailable()) {
+    console.log(
+      `Installing python dependencies using poetry. This may take a while...`,
+    );
+    const installSuccessful = tryPoetryInstall(noRoot);
+    if (!installSuccessful) {
+      console.error(
+        red(
+          "Installing dependencies using poetry failed. Please check error log above and try running create-llama again.",
+        ),
+      );
+      process.exit(1);
+    }
+  } else {
+    console.error(
+      red(
+        `Poetry is not available in the current environment. Please check ${terminalLink(
+          "Poetry Installation",
+          `https://python-poetry.org/docs/#installation`,
+        )} to install poetry first, then run create-llama again.`,
+      ),
+    );
+    process.exit(1);
+  }
+};
+
+const installLegacyPythonTemplate = async ({
+  root,
+  template,
+  vectorDb,
+  dataSources,
+  tools,
+  useCase,
+  observability,
+}: Pick<
+  InstallTemplateArgs,
+  | "root"
+  | "template"
+  | "vectorDb"
+  | "dataSources"
+  | "tools"
+  | "useCase"
+  | "observability"
+>) => {
+  const compPath = path.join(templatesDir, "components");
+  const enginePath = path.join(root, "app", "engine");
+
+  // Copy selected vector DB
+  await copy("**", enginePath, {
+    parents: true,
+    cwd: path.join(compPath, "vectordbs", "python", vectorDb ?? "none"),
+  });
+
+  if (vectorDb !== "llamacloud") {
+    // Copy all loaders to enginePath
+    // Not needed for LlamaCloud as it has its own loaders
+    const loaderPath = path.join(enginePath, "loaders");
+    await copy("**", loaderPath, {
+      parents: true,
+      cwd: path.join(compPath, "loaders", "python"),
+    });
+  }
+
+  // Copy settings.py to app
+  await copy("**", path.join(root, "app"), {
+    cwd: path.join(compPath, "settings", "python"),
+  });
+
+  // Copy services
+  if (template == "streaming" || template == "multiagent") {
+    await copy("**", path.join(root, "app", "api", "services"), {
+      cwd: path.join(compPath, "services", "python"),
+    });
+  }
+  // Copy engine code
+  if (template === "streaming" || template === "multiagent") {
+    // Select and copy engine code based on data sources and tools
+    let engine;
+    // Multiagent always uses agent engine
+    if (template === "multiagent") {
+      engine = "agent";
+    } else {
+      // For streaming, use chat engine by default
+      // Unless tools are selected, in which case use agent engine
+      if (dataSources.length > 0 && (!tools || tools.length === 0)) {
+        console.log(
+          "\nNo tools selected - use optimized context chat engine\n",
+        );
+        engine = "chat";
+      } else {
+        engine = "agent";
+      }
+    }
+
+    // Copy engine code
+    await copy("**", enginePath, {
+      parents: true,
+      cwd: path.join(compPath, "engines", "python", engine),
+    });
+
+    // Copy router code
+    await copyRouterCode(root, tools ?? []);
+  }
+
+  // Copy multiagents overrides
+  if (template === "multiagent") {
+    await copy("**", path.join(root), {
+      cwd: path.join(compPath, "multiagent", "python"),
+    });
+  }
+
+  if (template === "multiagent" || template === "reflex") {
+    if (useCase) {
+      const sourcePath =
+        template === "multiagent"
+          ? path.join(compPath, "agents", "python", useCase)
+          : path.join(compPath, "reflex", useCase);
+
+      await copy("**", path.join(root), {
+        parents: true,
+        cwd: sourcePath,
+        rename: assetRelocator,
+      });
+    } else {
+      console.log(
+        red(
+          `There is no use case selected for ${template} template. Please pick a use case to use via --use-case flag.`,
+        ),
+      );
+      process.exit(1);
+    }
+  }
+
+  if (observability && observability !== "none") {
+    const templateObservabilityPath = path.join(
+      templatesDir,
+      "components",
+      "observability",
+      "python",
+      observability,
+    );
+    await copy("**", path.join(root, "app"), {
+      cwd: templateObservabilityPath,
+    });
+  }
+};
+
+const installLlamaIndexServerTemplate = async ({
+  root,
+  useCase,
+  useLlamaParse,
+}: Pick<InstallTemplateArgs, "root" | "useCase" | "useLlamaParse">) => {
+  if (!useCase) {
+    console.log(
+      red(
+        `There is no use case selected. Please pick a use case to use via --use-case flag.`,
+      ),
+    );
+    process.exit(1);
+  }
+
+  await copy("workflow.py", path.join(root, "app"), {
+    parents: true,
+    cwd: path.join(templatesDir, "components", "workflows", "python", useCase),
+  });
+
+  // Copy custom UI component code
+  await copy(`*`, path.join(root, "components"), {
+    parents: true,
+    cwd: path.join(templatesDir, "components", "ui", "workflows", useCase),
+  });
+
+  if (useLlamaParse) {
+    await copy("index.py", path.join(root, "app"), {
+      parents: true,
+      cwd: path.join(
+        templatesDir,
+        "components",
+        "vectordbs",
+        "llamaindexserver",
+        "llamacloud",
+        "python",
+      ),
+    });
+    // TODO: Consider moving generate.py to app folder.
+    await copy("generate.py", path.join(root), {
+      parents: true,
+      cwd: path.join(
+        templatesDir,
+        "components",
+        "vectordbs",
+        "llamaindexserver",
+        "llamacloud",
+        "python",
+      ),
+    });
+  }
+  // Copy README.md
+  await copy("README-template.md", path.join(root), {
+    parents: true,
+    cwd: path.join(templatesDir, "components", "workflows", "python", useCase),
+    rename: assetRelocator,
+  });
+};
+
+export const installPythonTemplate = async ({
+  appName,
+  root,
+  template,
+  framework,
+  vectorDb,
+  postInstallAction,
+  modelConfig,
+  dataSources,
+  tools,
+  useLlamaParse,
+  useCase,
+  observability,
+}: Pick<
+  InstallTemplateArgs,
+  | "appName"
+  | "root"
+  | "template"
+  | "framework"
+  | "vectorDb"
+  | "postInstallAction"
+  | "modelConfig"
+  | "dataSources"
+  | "tools"
+  | "useLlamaParse"
+  | "useCase"
+  | "observability"
+>) => {
+  console.log("\nInitializing Python project with template:", template, "\n");
+  let templatePath;
+  if (template === "reflex") {
+    templatePath = path.join(templatesDir, "types", "reflex");
+  } else {
+    templatePath = path.join(templatesDir, "types", template, framework);
+  }
+  await copy("**", root, {
+    parents: true,
+    cwd: templatePath,
+    rename: assetRelocator,
+  });
+
+  if (template === "llamaindexserver") {
+    await installLlamaIndexServerTemplate({
+      root,
+      useCase,
+      useLlamaParse,
+    });
+  } else {
+    await installLegacyPythonTemplate({
+      root,
+      template,
+      vectorDb,
+      dataSources,
+      tools,
+      useCase,
+      observability,
+    });
+  }
+
+  console.log("Adding additional dependencies");
+  const addOnDependencies = getAdditionalDependencies(
+    modelConfig,
+    vectorDb,
+    dataSources,
+    tools,
+    template,
+  );
+
+  await addDependencies(root, addOnDependencies);
+
+  if (postInstallAction === "runApp" || postInstallAction === "dependencies") {
+    installPythonDependencies();
+  }
+};
@@ -0,0 +1,134 @@
+import { createWriteStream, promises } from "fs";
+import got from "got";
+import { tmpdir } from "os";
+import { join } from "path";
+import { Stream } from "stream";
+import tar from "tar";
+import { promisify } from "util";
+import { makeDir } from "./make-dir";
+import { CommunityProjectConfig } from "./types";
+
+export type RepoInfo = {
+  username: string;
+  name: string;
+  branch: string;
+  filePath: string;
+};
+
+const pipeline = promisify(Stream.pipeline);
+
+async function downloadTar(url: string) {
+  const tempFile = join(tmpdir(), `next.js-cna-example.temp-${Date.now()}`);
+  await pipeline(got.stream(url), createWriteStream(tempFile));
+  return tempFile;
+}
+
+export async function downloadAndExtractRepo(
+  root: string,
+  { username, name, branch, filePath }: RepoInfo,
+) {
+  await makeDir(root);
+
+  const tempFile = await downloadTar(
+    `https://codeload.github.com/${username}/${name}/tar.gz/${branch}`,
+  );
+
+  await tar.x({
+    file: tempFile,
+    cwd: root,
+    strip: filePath ? filePath.split("/").length + 1 : 1,
+    filter: (p) =>
+      p.startsWith(
+        `${name}-${branch.replace(/\//g, "-")}${
+          filePath ? `/${filePath}/` : "/"
+        }`,
+      ),
+  });
+
+  await promises.unlink(tempFile);
+}
+
+const getRepoInfo = async (owner: string, repo: string) => {
+  const repoInfoRes = await got(
+    `https://api.github.com/repos/${owner}/${repo}`,
+    {
+      responseType: "json",
+    },
+  );
+  const data = repoInfoRes.body as any;
+  return data;
+};
+
+export async function getProjectOptions(
+  owner: string,
+  repo: string,
+): Promise<
+  {
+    value: CommunityProjectConfig;
+    title: string;
+  }[]
+> {
+  // TODO: consider using octokit (https://github.com/octokit) if more changes are needed in the future
+  const getCommunityProjectConfig = async (
+    item: any,
+  ): Promise<CommunityProjectConfig | null> => {
+    // if item is a folder, return the path with default owner, repo, and main branch
+    if (item.type === "dir")
+      return {
+        owner,
+        repo,
+        branch: "main",
+        filePath: item.path,
+      };
+
+    // check if it's a submodule (has size = 0 and different owner & repo)
+    if (item.type === "file") {
+      if (item.size !== 0) return null; // submodules have size = 0
+
+      // get owner and repo from git_url
+      const { git_url } = item;
+      const startIndex = git_url.indexOf("repos/") + 6;
+      const endIndex = git_url.indexOf("/git");
+      const ownerRepoStr = git_url.substring(startIndex, endIndex);
+      const [owner, repo] = ownerRepoStr.split("/");
+
+      // quick fetch repo info to get the default branch
+      const { default_branch } = await getRepoInfo(owner, repo);
+
+      // return the path with default owner, repo, and main branch (path is empty for submodules)
+      return {
+        owner,
+        repo,
+        branch: default_branch,
+      };
+    }
+
+    return null;
+  };
+
+  const url = `https://api.github.com/repos/${owner}/${repo}/contents`;
+  const response = await got(url, {
+    responseType: "json",
+  });
+  const data = response.body as any[];
+
+  const projectConfigs: CommunityProjectConfig[] = [];
+  for (const item of data) {
+    const communityProjectConfig = await getCommunityProjectConfig(item);
+    if (communityProjectConfig) projectConfigs.push(communityProjectConfig);
+  }
+  return projectConfigs.map((config) => {
+    return {
+      value: config,
+      title: config.filePath || config.repo, // for submodules, use repo name as title
+    };
+  });
+}
+
+export async function getRepoRawContent(repoFilePath: string) {
+  const url = `https://raw.githubusercontent.com/${repoFilePath}`;
+  const response = await got(url, {
+    responseType: "text",
+  });
+  return response.body;
+}
@@ -26,13 +26,22 @@ const createProcess = (
  });
 };

-export function runFastAPIApp(
-  appPath: string,
-  port: number,
-  template: TemplateType,
-) {
-  const commandArgs = ["run", "fastapi", "dev", "--port", `${port}`];
-  return createProcess("uv", commandArgs, {
+export function runReflexApp(appPath: string, port: number) {
+  const commandArgs = [
+    "run",
+    "reflex",
+    "run",
+    "--frontend-port",
+    port.toString(),
+  ];
+  return createProcess("poetry", commandArgs, {
+    stdio: "inherit",
+    cwd: appPath,
+  });
+}
+
+export function runFastAPIApp(appPath: string, port: number) {
+  return createProcess("poetry", ["run", "dev"], {
    stdio: "inherit",
    cwd: appPath,
    env: { ...process.env, APP_PORT: `${port}` },
@@ -55,10 +64,16 @@ export async function runApp(
 ): Promise<void> {
  try {
    // Start the app
-    const defaultPort = framework === "nextjs" ? 3000 : 8000;
+    const defaultPort =
+      framework === "nextjs" || template === "reflex" ? 3000 : 8000;

-    const appRunner = framework === "fastapi" ? runFastAPIApp : runTSApp;
-    await appRunner(appPath, port || defaultPort, template);
+    const appRunner =
+      template === "reflex"
+        ? runReflexApp
+        : framework === "fastapi"
+          ? runFastAPIApp
+          : runTSApp;
+    await appRunner(appPath, port || defaultPort);
  } catch (error) {
    console.error("Failed to run app:", error);
    throw error;
@@ -0,0 +1,340 @@
+import fs from "fs/promises";
+import path from "path";
+import { red } from "picocolors";
+import yaml from "yaml";
+import { EnvVar } from "./env-variables";
+import { makeDir } from "./make-dir";
+import { TemplateFramework } from "./types";
+
+export const TOOL_SYSTEM_PROMPT_ENV_VAR = "TOOL_SYSTEM_PROMPT";
+
+export enum ToolType {
+  LLAMAHUB = "llamahub",
+  LOCAL = "local",
+}
+
+export type Tool = {
+  display: string;
+  name: string;
+  config?: Record<string, any>;
+  dependencies?: ToolDependencies[];
+  supportedFrameworks?: Array<TemplateFramework>;
+  type: ToolType;
+  envVars?: EnvVar[];
+};
+
+export type ToolDependencies = {
+  name: string;
+  version?: string;
+};
+
+export const supportedTools: Tool[] = [
+  {
+    display: "Google Search",
+    name: "google.GoogleSearchToolSpec",
+    config: {
+      engine:
+        "Your search engine id, see https://developers.google.com/custom-search/v1/overview#prerequisites",
+      key: "Your search api key",
+      num: 2,
+    },
+    dependencies: [
+      {
+        name: "llama-index-tools-google",
+        version: "^0.3.0",
+      },
+    ],
+    supportedFrameworks: ["fastapi"],
+    type: ToolType.LLAMAHUB,
+    envVars: [
+      {
+        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
+        description: "System prompt for google search tool.",
+        value: `You are a Google search agent. You help users to get information from Google search.`,
+      },
+    ],
+  },
+  {
+    // For python app, we will use a local DuckDuckGo search tool (instead of DuckDuckGo search tool in LlamaHub)
+    // to get the same results as the TS app.
+    display: "DuckDuckGo Search",
+    name: "duckduckgo",
+    dependencies: [
+      {
+        name: "duckduckgo-search",
+        version: "^6.3.5",
+      },
+    ],
+    supportedFrameworks: ["fastapi"], // TODO: Re-enable this tool once the duck-duck-scrape TypeScript library works again
+    type: ToolType.LOCAL,
+    envVars: [
+      {
+        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
+        description: "System prompt for DuckDuckGo search tool.",
+        value: `You have access to the duckduckgo search tool. Use it to get information from the web to answer user questions.
+For better results, you can specify the region parameter to get results from a specific region but it's optional.`,
+      },
+    ],
+  },
+  {
+    display: "Wikipedia",
+    name: "wikipedia.WikipediaToolSpec",
+    dependencies: [
+      {
+        name: "llama-index-tools-wikipedia",
+        version: "^0.3.0",
+      },
+    ],
+    supportedFrameworks: ["fastapi", "express", "nextjs"],
+    type: ToolType.LLAMAHUB,
+  },
+  {
+    display: "Weather",
+    name: "weather",
+    dependencies: [],
+    supportedFrameworks: ["fastapi", "express", "nextjs"],
+    type: ToolType.LOCAL,
+  },
+  {
+    display: "Document generator",
+    name: "document_generator",
+    supportedFrameworks: ["fastapi", "nextjs", "express"],
+    dependencies: [
+      {
+        name: "xhtml2pdf",
+        version: "^0.2.14",
+      },
+      {
+        name: "markdown",
+        version: "^3.7",
+      },
+    ],
+    type: ToolType.LOCAL,
+    envVars: [
+      {
+        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
+        description: "System prompt for document generator tool.",
+        value: `If user request for a report or a post, use document generator tool to create a file and reply with the link to the file.`,
+      },
+    ],
+  },
+  {
+    display: "Code Interpreter",
+    name: "interpreter",
+    dependencies: [
+      {
+        name: "e2b_code_interpreter",
+        version: "1.1.1",
+      },
+    ],
+    supportedFrameworks: ["fastapi", "express", "nextjs"],
+    type: ToolType.LOCAL,
+    envVars: [
+      {
+        name: "E2B_API_KEY",
+        description:
+          "E2B_API_KEY key is required to run code interpreter tool. Get it here: https://e2b.dev/docs/getting-started/api-key",
+      },
+      {
+        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
+        description: "System prompt for code interpreter tool.",
+        value: `-You are a Python interpreter that can run any python code in a secure environment.
+- The python code runs in a Jupyter notebook. Every time you call the 'interpreter' tool, the python code is executed in a separate cell. 
+- You are given tasks to complete and you run python code to solve them.
+- It's okay to make multiple calls to interpreter tool. If you get an error or the result is not what you expected, you can call the tool again. Don't give up too soon!
+- Plot visualizations using matplotlib or any other visualization library directly in the notebook.
+- You can install any pip package (if it exists) by running a cell with pip install.`,
+      },
+    ],
+  },
+  {
+    display: "Artifact Code Generator",
+    name: "artifact",
+    // Using pre-release version of e2b_code_interpreter
+    // TODO: Update to stable version when 0.0.11 is released
+    dependencies: [
+      {
+        name: "e2b_code_interpreter",
+        version: "1.1.1",
+      },
+    ],
+    supportedFrameworks: ["fastapi", "express", "nextjs"],
+    type: ToolType.LOCAL,
+    envVars: [
+      {
+        name: "E2B_API_KEY",
+        description:
+          "E2B_API_KEY key is required to run artifact code generator tool. Get it here: https://e2b.dev/docs/getting-started/api-key",
+      },
+      {
+        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
+        description: "System prompt for artifact code generator tool.",
+        value:
+          "You are a code assistant that can generate and execute code using its tools. Don't generate code yourself, use the provided tools instead. Do not show the code or sandbox url in chat, just describe the steps to build the application based on the code that is generated by your tools. Do not describe how to run the code, just the steps to build the application.",
+      },
+    ],
+  },
+  {
+    display: "OpenAPI action",
+    name: "openapi_action.OpenAPIActionToolSpec",
+    dependencies: [
+      {
+        name: "llama-index-tools-openapi",
+        version: "0.2.0",
+      },
+      {
+        name: "jsonschema",
+        version: "^4.22.0",
+      },
+      {
+        name: "llama-index-tools-requests",
+        version: "0.2.0",
+      },
+    ],
+    config: {
+      openapi_uri: "The URL or file path of the OpenAPI schema",
+    },
+    supportedFrameworks: ["fastapi", "express", "nextjs"],
+    type: ToolType.LOCAL,
+  },
+  {
+    display: "Image Generator",
+    name: "img_gen",
+    supportedFrameworks: ["fastapi", "express", "nextjs"],
+    type: ToolType.LOCAL,
+    envVars: [
+      {
+        name: "STABILITY_API_KEY",
+        description:
+          "STABILITY_API_KEY key is required to run image generator. Get it here: https://platform.stability.ai/account/keys",
+      },
+    ],
+  },
+  {
+    display: "Azure Code Interpreter",
+    name: "azure_code_interpreter.AzureCodeInterpreterToolSpec",
+    supportedFrameworks: ["fastapi", "nextjs", "express"],
+    type: ToolType.LLAMAHUB,
+    dependencies: [
+      {
+        name: "llama-index-tools-azure-code-interpreter",
+        version: "0.2.0",
+      },
+    ],
+    envVars: [
+      {
+        name: "AZURE_POOL_MANAGEMENT_ENDPOINT",
+        description:
+          "Please follow this guideline to create and get the pool management endpoint: https://learn.microsoft.com/azure/container-apps/sessions?tabs=azure-cli",
+      },
+      {
+        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
+        description: "System prompt for Azure code interpreter tool.",
+        value: `-You are a Python interpreter that can run any python code in a secure environment.
+- The python code runs in a Jupyter notebook. Every time you call the 'interpreter' tool, the python code is executed in a separate cell. 
+- You are given tasks to complete and you run python code to solve them.
+- It's okay to make multiple calls to interpreter tool. If you get an error or the result is not what you expected, you can call the tool again. Don't give up too soon!
+- Plot visualizations using matplotlib or any other visualization library directly in the notebook.
+- You can install any pip package (if it exists) by running a cell with pip install.`,
+      },
+    ],
+  },
+  {
+    display: "Form Filling",
+    name: "form_filling",
+    supportedFrameworks: ["fastapi"],
+    type: ToolType.LOCAL,
+    dependencies: [
+      {
+        name: "pandas",
+        version: "^2.2.3",
+      },
+      {
+        name: "tabulate",
+        version: "^0.9.0",
+      },
+    ],
+  },
+];
+
+export const getTool = (toolName: string): Tool | undefined => {
+  return supportedTools.find((tool) => tool.name === toolName);
+};
+
+export const getTools = (toolsName: string[]): Tool[] => {
+  const tools: Tool[] = [];
+  for (const toolName of toolsName) {
+    const tool = getTool(toolName);
+    if (!tool) {
+      console.log(
+        red(
+          `Error: Tool '${toolName}' is not supported. Supported tools are: ${supportedTools
+            .map((t) => t.name)
+            .join(", ")}`,
+        ),
+      );
+      process.exit(1);
+    }
+    tools.push(tool);
+  }
+  return tools;
+};
+
+export const toolRequiresConfig = (tool: Tool): boolean => {
+  const hasConfig = Object.keys(tool.config || {}).length > 0;
+  const hasEmptyEnvVar = tool.envVars?.some((envVar) => !envVar.value) ?? false;
+  return hasConfig || hasEmptyEnvVar;
+};
+
+export const toolsRequireConfig = (tools?: Tool[]): boolean => {
+  if (tools) {
+    return tools?.some(toolRequiresConfig);
+  }
+  return false;
+};
+
+export enum ConfigFileType {
+  YAML = "yaml",
+  JSON = "json",
+}
+
+export const writeToolsConfig = async (
+  root: string,
+  tools: Tool[] = [],
+  type: ConfigFileType = ConfigFileType.YAML,
+) => {
+  const configContent: {
+    [key in ToolType]: Record<string, any>;
+  } = {
+    local: {},
+    llamahub: {},
+  };
+  tools.forEach((tool) => {
+    if (tool.type === ToolType.LLAMAHUB) {
+      configContent.llamahub[tool.name] = tool.config ?? {};
+    }
+    if (tool.type === ToolType.LOCAL) {
+      configContent.local[tool.name] = tool.config ?? {};
+    }
+  });
+  const configPath = path.join(root, "config");
+  await makeDir(configPath);
+  if (type === ConfigFileType.YAML) {
+    await fs.writeFile(
+      path.join(configPath, "tools.yaml"),
+      yaml.stringify(configContent),
+    );
+  } else {
+    // For Typescript, we treat llamahub tools as local tools
+    const tsConfigContent = {
+      local: {
+        ...configContent.local,
+        ...configContent.llamahub,
+      },
+    };
+    await fs.writeFile(
+      path.join(configPath, "tools.json"),
+      JSON.stringify(tsConfigContent, null, 2),
+    );
+  }
+};
@@ -1,4 +1,5 @@
 import { PackageManager } from "../helpers/get-pkg-manager";
+import { Tool } from "./tools";

 export type ModelProvider =
  | "openai"
@@ -18,8 +19,15 @@ export type ModelConfig = {
  dimensions: number;
  isConfigured(): boolean;
 };
-export type TemplateType = "llamaindexserver";
+export type TemplateType =
+  | "streaming"
+  | "community"
+  | "llamapack"
+  | "multiagent"
+  | "reflex"
+  | "llamaindexserver";
 export type TemplateFramework = "nextjs" | "express" | "fastapi";
+export type TemplateUI = "html" | "shadcn";
 export type TemplateVectorDB =
  | "none"
  | "mongo"
@@ -41,22 +49,15 @@ export type TemplateDataSource = {
  config: TemplateDataSourceConfig;
 };
 export type TemplateDataSourceType = "file" | "web" | "db";
+export type TemplateObservability = "none" | "traceloop" | "llamatrace";
 export type TemplateUseCase =
  | "financial_report"
+  | "blog"
  | "deep_research"
-  | "agentic_rag"
-  | "code_generator"
-  | "document_generator"
-  | "hitl";
-
-export const ALL_USE_CASES: TemplateUseCase[] = [
-  "agentic_rag",
-  "deep_research",
-  "financial_report",
-  "code_generator",
-  "document_generator",
-  "hitl",
-];
+  | "form_filling"
+  | "extractor"
+  | "contract_review"
+  | "agentic_rag";
 // Config for both file and folder
 export type FileSourceConfig =
  | {
@@ -82,18 +83,31 @@ export type TemplateDataSourceConfig =
  | WebSourceConfig
  | DbSourceConfig;

+export type CommunityProjectConfig = {
+  owner: string;
+  repo: string;
+  branch: string;
+  filePath?: string;
+};
+
 export interface InstallTemplateArgs {
  appName: string;
  root: string;
  packageManager: PackageManager;
+  isOnline: boolean;
  template: TemplateType;
  framework: TemplateFramework;
+  ui: TemplateUI;
  dataSources: TemplateDataSource[];
  modelConfig: ModelConfig;
  llamaCloudKey?: string;
-  useLlamaParse: boolean;
-  vectorDb: TemplateVectorDB;
+  useLlamaParse?: boolean;
+  communityProjectConfig?: CommunityProjectConfig;
+  llamapack?: string;
+  vectorDb?: TemplateVectorDB;
  port?: number;
-  postInstallAction: TemplatePostInstallAction;
-  useCase: TemplateUseCase;
+  postInstallAction?: TemplatePostInstallAction;
+  tools?: Tool[];
+  observability?: TemplateObservability;
+  useCase?: TemplateUseCase;
 }
@@ -0,0 +1,576 @@
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import { bold, cyan, red, yellow } from "picocolors";
+import { assetRelocator, copy } from "../helpers/copy";
+import { callPackageManager } from "../helpers/install";
+import { templatesDir } from "./dir";
+import { PackageManager } from "./get-pkg-manager";
+import { InstallTemplateArgs, ModelProvider, TemplateVectorDB } from "./types";
+
+const installLlamaIndexServerTemplate = async ({
+  root,
+  useCase,
+  vectorDb,
+}: Pick<InstallTemplateArgs, "root" | "useCase" | "vectorDb">) => {
+  if (!useCase) {
+    console.log(
+      red(
+        `There is no use case selected. Please pick a use case to use via --use-case flag.`,
+      ),
+    );
+    process.exit(1);
+  }
+
+  if (!vectorDb) {
+    console.log(
+      red(
+        `There is no vector db selected. Please pick a vector db to use via --vector-db flag.`,
+      ),
+    );
+    process.exit(1);
+  }
+
+  await copy("workflow.ts", path.join(root, "src", "app"), {
+    parents: true,
+    cwd: path.join(
+      templatesDir,
+      "components",
+      "workflows",
+      "typescript",
+      useCase,
+    ),
+  });
+
+  // copy workflow UI components to output/components folder
+  await copy("*", path.join(root, "components"), {
+    parents: true,
+    cwd: path.join(templatesDir, "components", "ui", "workflows", useCase),
+  });
+
+  if (vectorDb === "llamacloud") {
+    await copy("generate.ts", path.join(root, "src"), {
+      parents: true,
+      cwd: path.join(
+        templatesDir,
+        "components",
+        "vectordbs",
+        "llamaindexserver",
+        "llamacloud",
+        "typescript",
+      ),
+    });
+
+    await copy("index.ts", path.join(root, "src", "app"), {
+      parents: true,
+      cwd: path.join(
+        templatesDir,
+        "components",
+        "vectordbs",
+        "llamaindexserver",
+        "llamacloud",
+        "typescript",
+      ),
+      rename: () => "data.ts",
+    });
+  }
+  // Copy README.md
+  await copy("README-template.md", path.join(root), {
+    parents: true,
+    cwd: path.join(
+      templatesDir,
+      "components",
+      "workflows",
+      "typescript",
+      useCase,
+    ),
+    rename: assetRelocator,
+  });
+};
+
+const installLegacyTSTemplate = async ({
+  root,
+  template,
+  backend,
+  framework,
+  ui,
+  vectorDb,
+  observability,
+  tools,
+  dataSources,
+  useLlamaParse,
+  useCase,
+  modelConfig,
+  relativeEngineDestPath,
+}: InstallTemplateArgs & {
+  backend: boolean;
+  relativeEngineDestPath: string;
+}) => {
+  /**
+   * If next.js is used, update its configuration if necessary
+   */
+  if (framework === "nextjs") {
+    const nextConfigJsonFile = path.join(root, "next.config.json");
+    const nextConfigJson: any = JSON.parse(
+      await fs.readFile(nextConfigJsonFile, "utf8"),
+    );
+    if (!backend) {
+      // update next.config.json for static site generation
+      nextConfigJson.output = "export";
+      nextConfigJson.images = { unoptimized: true };
+      console.log("\nUsing static site generation\n");
+    } else {
+      if (vectorDb === "milvus") {
+        nextConfigJson.serverExternalPackages =
+          nextConfigJson.serverExternalPackages ?? [];
+        nextConfigJson.serverExternalPackages.push("@zilliz/milvus2-sdk-node");
+      }
+    }
+    await fs.writeFile(
+      nextConfigJsonFile,
+      JSON.stringify(nextConfigJson, null, 2) + os.EOL,
+    );
+
+    const webpackConfigOtelFile = path.join(root, "webpack.config.o11y.mjs");
+    if (observability === "traceloop") {
+      const webpackConfigDefaultFile = path.join(root, "webpack.config.mjs");
+      await fs.rm(webpackConfigDefaultFile);
+      await fs.rename(webpackConfigOtelFile, webpackConfigDefaultFile);
+    } else {
+      await fs.rm(webpackConfigOtelFile);
+    }
+  }
+
+  // copy observability component
+  if (observability && observability !== "none") {
+    const chosenObservabilityPath = path.join(
+      templatesDir,
+      "components",
+      "observability",
+      "typescript",
+      observability,
+    );
+    const relativeObservabilityPath = framework === "nextjs" ? "app" : "src";
+
+    await copy(
+      "**",
+      path.join(root, relativeObservabilityPath, "observability"),
+      { cwd: chosenObservabilityPath },
+    );
+  }
+
+  const compPath = path.join(templatesDir, "components");
+  const enginePath = path.join(root, relativeEngineDestPath, "engine");
+
+  // copy llamaindex code for TS templates
+  await copy("**", path.join(root, relativeEngineDestPath, "llamaindex"), {
+    parents: true,
+    cwd: path.join(compPath, "llamaindex", "typescript"),
+  });
+
+  // copy vector db component
+  if (vectorDb === "llamacloud") {
+    console.log(
+      `\nUsing managed index from LlamaCloud. Ensure the ${yellow("LLAMA_CLOUD_* environment variables are set correctly.")}`,
+    );
+  } else {
+    console.log("\nUsing vector DB:", vectorDb ?? "none");
+  }
+  await copy("**", enginePath, {
+    parents: true,
+    cwd: path.join(compPath, "vectordbs", "typescript", vectorDb ?? "none"),
+  });
+
+  if (template === "multiagent") {
+    const multiagentPath = path.join(compPath, "multiagent", "typescript");
+
+    // copy workflow code for multiagent template
+    await copy("**", path.join(root, relativeEngineDestPath, "workflow"), {
+      parents: true,
+      cwd: path.join(multiagentPath, "workflow"),
+    });
+
+    // Copy use case code for multiagent template
+    if (useCase) {
+      console.log("\nCopying use case:", useCase, "\n");
+      const useCasePath = path.join(compPath, "agents", "typescript", useCase);
+      const useCaseCodePath = path.join(useCasePath, "workflow");
+
+      // Copy use case codes
+      await copy("**", path.join(root, relativeEngineDestPath, "workflow"), {
+        parents: true,
+        cwd: useCaseCodePath,
+        rename: assetRelocator,
+      });
+
+      // Copy use case files to project root
+      await copy("*.*", path.join(root), {
+        parents: true,
+        cwd: useCasePath,
+        rename: assetRelocator,
+      });
+    } else {
+      console.log(
+        red(
+          `There is no use case selected for ${template} template. Please pick a use case to use via --use-case flag.`,
+        ),
+      );
+      process.exit(1);
+    }
+
+    if (framework === "nextjs") {
+      // patch route.ts file
+      await copy("**", path.join(root, relativeEngineDestPath), {
+        parents: true,
+        cwd: path.join(multiagentPath, "nextjs"),
+      });
+    } else if (framework === "express") {
+      // patch chat.controller.ts file
+      await copy("**", path.join(root, relativeEngineDestPath), {
+        parents: true,
+        cwd: path.join(multiagentPath, "express"),
+      });
+    }
+  }
+
+  // copy loader component (TS only supports llama_parse and file for now)
+  const loaderFolder = useLlamaParse ? "llama_parse" : "file";
+  await copy("**", enginePath, {
+    parents: true,
+    cwd: path.join(compPath, "loaders", "typescript", loaderFolder),
+  });
+
+  // copy provider settings
+  await copy("**", enginePath, {
+    parents: true,
+    cwd: path.join(compPath, "providers", "typescript", modelConfig.provider),
+  });
+
+  // Select and copy engine code based on data sources and tools
+  let engine;
+  tools = tools ?? [];
+  // multiagent template always uses agent engine
+  if (template === "multiagent") {
+    engine = "agent";
+  } else if (dataSources.length > 0 && tools.length === 0) {
+    console.log("\nNo tools selected - use optimized context chat engine\n");
+    engine = "chat";
+  } else {
+    engine = "agent";
+  }
+  await copy("**", enginePath, {
+    parents: true,
+    cwd: path.join(compPath, "engines", "typescript", engine),
+  });
+
+  // copy settings to engine folder
+  await copy("**", enginePath, {
+    cwd: path.join(compPath, "settings", "typescript"),
+  });
+
+  /**
+   * Copy the selected UI files to the target directory and reference it.
+   */
+  if (framework === "nextjs" && ui !== "shadcn") {
+    console.log("\nUsing UI:", ui, "\n");
+    const uiPath = path.join(compPath, "ui", ui);
+    const destUiPath = path.join(root, "app", "components", "ui");
+    // remove the default ui folder
+    await fs.rm(destUiPath, { recursive: true });
+    // copy the selected ui folder
+    await copy("**", destUiPath, {
+      parents: true,
+      cwd: uiPath,
+      rename: assetRelocator,
+    });
+  }
+
+  /** Modify frontend code to use custom API path */
+  if (framework === "nextjs" && !backend) {
+    console.log(
+      "\nUsing external API for frontend, removing API code and configuration\n",
+    );
+    // remove the default api folder and config folder
+    await fs.rm(path.join(root, "app", "api"), { recursive: true });
+    await fs.rm(path.join(root, "config"), { recursive: true, force: true });
+  }
+};
+
+/**
+ * Install a LlamaIndex internal template to a given `root` directory.
+ */
+export const installTSTemplate = async ({
+  appName,
+  root,
+  packageManager,
+  isOnline,
+  template,
+  framework,
+  ui,
+  vectorDb,
+  postInstallAction,
+  backend,
+  observability,
+  tools,
+  dataSources,
+  useLlamaParse,
+  useCase,
+  modelConfig,
+}: InstallTemplateArgs & { backend: boolean }) => {
+  console.log(bold(`Using ${packageManager}.`));
+
+  /**
+   * Copy the template files to the target directory.
+   */
+  console.log("\nInitializing project with template:", template, "\n");
+  const templatePath = path.join(templatesDir, "types", template, framework);
+  const copySource = ["**"];
+
+  await copy(copySource, root, {
+    parents: true,
+    cwd: templatePath,
+    rename: assetRelocator,
+  });
+
+  const relativeEngineDestPath =
+    framework === "nextjs"
+      ? path.join("app", "api", "chat")
+      : path.join("src", "controllers");
+
+  if (template === "llamaindexserver") {
+    await installLlamaIndexServerTemplate({
+      root,
+      useCase,
+      vectorDb,
+    });
+  } else {
+    await installLegacyTSTemplate({
+      appName,
+      root,
+      packageManager,
+      isOnline,
+      template,
+      backend,
+      framework,
+      ui,
+      vectorDb,
+      observability,
+      tools,
+      dataSources,
+      useLlamaParse,
+      useCase,
+      modelConfig,
+      relativeEngineDestPath,
+    });
+  }
+
+  const packageJson = await updatePackageJson({
+    root,
+    appName,
+    dataSources,
+    relativeEngineDestPath,
+    framework,
+    ui,
+    observability,
+    vectorDb,
+    backend,
+    modelConfig,
+    template,
+  });
+
+  if (
+    backend &&
+    (postInstallAction === "runApp" || postInstallAction === "dependencies")
+  ) {
+    await installTSDependencies(packageJson, packageManager, isOnline);
+  }
+};
+
+const providerDependencies: {
+  [key in ModelProvider]?: Record<string, string>;
+} = {
+  openai: {
+    "@llamaindex/openai": "^0.2.0",
+  },
+  gemini: {
+    "@llamaindex/google": "^0.2.0",
+  },
+  ollama: {
+    "@llamaindex/ollama": "^0.1.0",
+  },
+  mistral: {
+    "@llamaindex/mistral": "^0.2.0",
+  },
+  "azure-openai": {
+    "@llamaindex/openai": "^0.2.0",
+  },
+  groq: {
+    "@llamaindex/groq": "^0.0.61",
+    "@llamaindex/huggingface": "^0.1.0", // groq uses huggingface as default embedding model
+  },
+  anthropic: {
+    "@llamaindex/anthropic": "^0.3.0",
+    "@llamaindex/huggingface": "^0.1.0", // anthropic uses huggingface as default embedding model
+  },
+};
+
+const vectorDbDependencies: Record<TemplateVectorDB, Record<string, string>> = {
+  astra: {
+    "@llamaindex/astra": "^0.0.5",
+  },
+  chroma: {
+    "@llamaindex/chroma": "^0.0.5",
+  },
+  llamacloud: {},
+  milvus: {
+    "@zilliz/milvus2-sdk-node": "^2.4.6",
+    "@llamaindex/milvus": "^0.1.0",
+  },
+  mongo: {
+    mongodb: "6.7.0",
+    "@llamaindex/mongodb": "^0.0.5",
+  },
+  none: {},
+  pg: {
+    pg: "^8.12.0",
+    pgvector: "^0.2.0",
+    "@llamaindex/postgres": "^0.0.33",
+  },
+  pinecone: {
+    "@llamaindex/pinecone": "^0.0.5",
+  },
+  qdrant: {
+    "@qdrant/js-client-rest": "^1.11.0",
+    "@llamaindex/qdrant": "^0.1.0",
+  },
+  weaviate: {
+    "@llamaindex/weaviate": "^0.0.5",
+  },
+};
+
+async function updatePackageJson({
+  root,
+  appName,
+  dataSources,
+  relativeEngineDestPath,
+  framework,
+  ui,
+  observability,
+  vectorDb,
+  backend,
+  modelConfig,
+  template,
+}: Pick<
+  InstallTemplateArgs,
+  | "root"
+  | "appName"
+  | "dataSources"
+  | "framework"
+  | "ui"
+  | "observability"
+  | "vectorDb"
+  | "modelConfig"
+  | "template"
+> & {
+  relativeEngineDestPath: string;
+  backend: boolean;
+}): Promise<any> {
+  const packageJsonFile = path.join(root, "package.json");
+  const packageJson: any = JSON.parse(
+    await fs.readFile(packageJsonFile, "utf8"),
+  );
+  packageJson.name = appName;
+  packageJson.version = "0.1.0";
+
+  if (relativeEngineDestPath && template !== "llamaindexserver") {
+    // TODO: move script to {root}/scripts for all frameworks
+    // add generate script if using context engine
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      generate: `tsx ${path.join(
+        relativeEngineDestPath,
+        "engine",
+        "generate.ts",
+      )}`,
+    };
+  }
+
+  if (framework === "nextjs" && ui === "html") {
+    // remove shadcn dependencies if html ui is selected
+    packageJson.dependencies = {
+      ...packageJson.dependencies,
+      "tailwind-merge": undefined,
+      "@radix-ui/react-slot": undefined,
+      "class-variance-authority": undefined,
+      clsx: undefined,
+      "lucide-react": undefined,
+      remark: undefined,
+      "remark-code-import": undefined,
+      "remark-gfm": undefined,
+      "remark-math": undefined,
+      "react-markdown": undefined,
+      "highlight.js": undefined,
+    };
+  }
+
+  if (backend) {
+    packageJson.dependencies = {
+      ...packageJson.dependencies,
+      "@llamaindex/readers": "^2.0.0",
+    };
+
+    if (vectorDb && vectorDb in vectorDbDependencies) {
+      packageJson.dependencies = {
+        ...packageJson.dependencies,
+        ...vectorDbDependencies[vectorDb],
+      };
+    }
+
+    if (modelConfig.provider && modelConfig.provider in providerDependencies) {
+      packageJson.dependencies = {
+        ...packageJson.dependencies,
+        ...providerDependencies[modelConfig.provider],
+      };
+    }
+  }
+
+  if (observability === "traceloop") {
+    packageJson.dependencies = {
+      ...packageJson.dependencies,
+      "@traceloop/node-server-sdk": "^0.5.19",
+    };
+
+    packageJson.devDependencies = {
+      ...packageJson.devDependencies,
+      "node-loader": "^2.0.0",
+    };
+  }
+
+  await fs.writeFile(
+    packageJsonFile,
+    JSON.stringify(packageJson, null, 2) + os.EOL,
+  );
+
+  return packageJson;
+}
+
+async function installTSDependencies(
+  packageJson: any,
+  packageManager: PackageManager,
+  isOnline: boolean,
+): Promise<void> {
+  console.log("\nInstalling dependencies:");
+  for (const dependency in packageJson.dependencies)
+    console.log(`- ${cyan(dependency)}`);
+
+  console.log("\nInstalling devDependencies:");
+  for (const dependency in packageJson.devDependencies)
+    console.log(`- ${cyan(dependency)}`);
+
+  console.log();
+
+  await callPackageManager(packageManager, isOnline).catch((error) => {
+    console.error("Failed to install TS dependencies. Exiting...");
+    process.exit(1);
+  });
+}
@@ -1,3 +1,4 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
 import validateProjectName from "validate-npm-package-name";

 export function validateNpmName(name: string): {
@@ -1,3 +1,4 @@
+/* eslint-disable import/no-extraneous-dependencies */
 import { execSync } from "child_process";
 import { Command } from "commander";
 import fs from "fs";
@@ -7,10 +8,12 @@ import prompts from "prompts";
 import terminalLink from "terminal-link";
 import checkForUpdate from "update-check";
 import { createApp } from "./create-app";
+import { EXAMPLE_FILE, getDataSources } from "./helpers/datasources";
 import { getPkgManager } from "./helpers/get-pkg-manager";
 import { isFolderEmpty } from "./helpers/is-folder-empty";
 import { initializeGlobalAgent } from "./helpers/proxy";
 import { runApp } from "./helpers/run-app";
+import { getTools } from "./helpers/tools";
 import { validateNpmName } from "./helpers/validate-pkg";
 import packageJson from "./package.json";
 import { askQuestions } from "./questions/index";
@@ -54,6 +57,13 @@ const program = new Command(packageJson.name)
    `

  Explicitly tell the CLI to bootstrap the application using Yarn
+`,
+  )
+  .option(
+    "--template <template>",
+    `
+
+  Select a template to bootstrap the application with.
 `,
  )
  .option(
@@ -61,6 +71,62 @@ const program = new Command(packageJson.name)
    `

  Select a framework to bootstrap the application with.
+`,
+  )
+  .option(
+    "--files <path>",
+    `
+  
+  Specify the path to a local file or folder for chatting.
+`,
+  )
+  .option(
+    "--example-file",
+    `
+
+  Select to use an example PDF as data source.
+`,
+  )
+  .option(
+    "--web-source <url>",
+    `
+  
+  Specify a website URL to use as a data source.
+`,
+  )
+  .option(
+    "--db-source <connection-string>",
+    `
+  
+  Specify a database connection string to use as a data source.
+`,
+  )
+  .option(
+    "--open-ai-key <key>",
+    `
+
+  Provide an OpenAI API key.
+`,
+  )
+  .option(
+    "--ui <ui>",
+    `
+
+  Select a UI to bootstrap the application with.
+`,
+  )
+  .option(
+    "--frontend",
+    `
+
+  Generate a frontend for your backend.
+`,
+  )
+  .option(
+    "--no-frontend",
+    `
+
+  Do not generate a frontend for your backend.
 `,
  )
  .option(
@@ -82,6 +148,27 @@ const program = new Command(packageJson.name)
    `

  Select which vector database you would like to use, such as 'none', 'pg' or 'mongo'. The default option is not to use a vector database and use the local filesystem instead ('none').
+`,
+  )
+  .option(
+    "--tools <tools>",
+    `
+
+  Specify the tools you want to use by providing a comma-separated list. For example, 'wikipedia.WikipediaToolSpec,google.GoogleSearchToolSpec'. Use 'none' to not using any tools.
+`,
+    (tools, _) => {
+      if (tools === "none") {
+        return [];
+      } else {
+        return getTools(tools.split(","));
+      }
+    },
+  )
+  .option(
+    "--use-llama-parse",
+    `
+
+  Enable LlamaParse.
 `,
  )
  .option(
@@ -91,12 +178,26 @@ const program = new Command(packageJson.name)
  Provide a LlamaCloud API key.
 `,
  )
-
+  .option(
+    "--observability <observability>",
+    `
+    
+  Specify observability tools to use. Eg: none, opentelemetry
+`,
+  )
  .option(
    "--ask-models",
    `

  Allow interactive selection of LLM and embedding models of different model providers.
+`,
+    false,
+  )
+  .option(
+    "--pro",
+    `
+
+  Allow interactive selection of all features.
 `,
    false,
  )
@@ -104,7 +205,7 @@ const program = new Command(packageJson.name)
    "--use-case <useCase>",
    `

-  Select which use case to use for the template (e.g: financial_report, blog).
+  Select which use case to use for the multi-agent template (e.g: financial_report, blog).
 `,
  )
  .allowUnknownOption()
@@ -112,6 +213,42 @@ const program = new Command(packageJson.name)

 const options = program.opts();

+if (
+  process.argv.includes("--no-llama-parse") ||
+  options.template === "reflex"
+) {
+  options.useLlamaParse = false;
+}
+if (process.argv.includes("--no-files")) {
+  options.dataSources = [];
+} else if (process.argv.includes("--example-file")) {
+  options.dataSources = getDataSources(options.files, options.exampleFile);
+} else if (process.argv.includes("--llamacloud")) {
+  options.dataSources = [EXAMPLE_FILE];
+  options.vectorDb = "llamacloud";
+} else if (process.argv.includes("--web-source")) {
+  options.dataSources = [
+    {
+      type: "web",
+      config: {
+        baseUrl: options.webSource,
+        prefix: options.webSource,
+        depth: 1,
+      },
+    },
+  ];
+} else if (process.argv.includes("--db-source")) {
+  options.dataSources = [
+    {
+      type: "db",
+      config: {
+        uri: options.dbSource,
+        queries: options.dbQuery || "SELECT * FROM mytable",
+      },
+    },
+  ];
+}
+
 const packageManager = !!options.useNpm
  ? "npm"
  : !!options.usePnpm
@@ -120,9 +257,6 @@ const packageManager = !!options.useNpm
      ? "yarn"
      : getPkgManager();

-// options above must use all the properties of QuestionArgs
-const cliArgs = options as unknown as QuestionArgs;
-
 async function run(): Promise<void> {
  if (typeof projectPath === "string") {
    projectPath = projectPath.trim();
@@ -186,7 +320,7 @@ async function run(): Promise<void> {
    process.exit(1);
  }

-  const answers = await askQuestions(cliArgs);
+  const answers = await askQuestions(options as unknown as QuestionArgs);

  await createApp({
    ...answers,
@@ -8,7 +8,6 @@ LlamaIndexServer is a FastAPI-based application that allows you to quickly launc
 - Built on FastAPI for high performance and easy API development
 - Optional built-in chat UI with extendable UI components
 - Prebuilt development code
- Human-in-the-loop (HITL) support, check out the [Human-in-the-loop](https://github.com/run-llama/create-llama/blob/main/python/llama-index-server/examples/hitl/README.md) documentation for more details.

 ## Installation

@@ -45,6 +44,7 @@ app = LlamaIndexServer(
    workflow_factory=create_workflow,  # Supports Workflow or AgentWorkflow
    env="dev",  # Enable development mode
    ui_config={ # Configure the chat UI, optional
+        "app_title": "Weather Bot",
        "starter_questions": ["What is the weather in LA?", "Will it rain in SF?"],
    },
    verbose=True
@@ -72,49 +72,21 @@ app = LlamaIndexServer(

 The LlamaIndexServer accepts the following configuration parameters:

- `workflow_factory`: A callable that creates a workflow instance for each request. See [Workflow factory contract](#workflow-factory-contract) for more details.
+- `workflow_factory`: A callable that creates a workflow instance for each request
 - `logger`: Optional logger instance (defaults to uvicorn logger)
 - `use_default_routers`: Whether to include default routers (chat, static file serving)
 - `env`: Environment setting ('dev' enables CORS and UI by default)
 - `ui_config`: UI configuration as a dictionary or UIConfig object with options:
  - `enabled`: Whether to enable the chat UI (default: True)
-  - `enable_file_upload`: Whether to enable file upload in the chat UI (default: False). Check [How to get the uploaded files in your workflow](https://github.com/run-llama/create-llama/blob/main/python/llama-index-server/examples/private_file/README.md#how-to-get-the-uploaded-files-in-your-workflow) for more details.
+  - `app_title`: The title of the chat application (default: "LlamaIndex Server")
  - `starter_questions`: List of starter questions for the chat UI (default: None)
  - `ui_path`: Path for downloaded UI static files (default: ".ui")
  - `component_dir`: The directory for custom UI components rendering events emitted by the workflow. The default is None, which does not render custom UI components.
-  - `layout_dir`: The directory for custom layout sections. The default value is `layout`. See [Custom Layout](https://github.com/run-llama/create-llama/blob/main/python/llama-index-server/docs/custom_layout.md) for more details.
  - `llamacloud_index_selector`: Whether to show the LlamaCloud index selector in the chat UI (default: False). Requires `LLAMA_CLOUD_API_KEY` to be set.
-  - `dev_mode`: When enabled, you can update workflow code in the UI and see the changes immediately. It's currently in beta and only supports updating workflow code at `app/workflow.py`. You might also need to set `env="dev"` and start the server with the reload feature enabled.
- `suggest_next_questions`: Whether to suggest next questions after the assistant's response (default: True). You can change the prompt for the next questions by setting the `NEXT_QUESTION_PROMPT` environment variable. The default prompt used is defined in  `llama_index.server.prompts.SUGGEST_NEXT_QUESTION_PROMPT`.
 - `verbose`: Enable verbose logging
 - `api_prefix`: API route prefix (default: "/api")
 - `server_url`: The deployment URL of the server (default is None)

-## Workflow factory contract
-
-The `workflow_factory` provided will be called for each chat request to initialize a new workflow instance. Additionally, we provide the [ChatRequest](https://github.com/run-llama/create-llama/blob/afe9e9fc16427d20e1dfb635a45e7ed4b46285cb/python/llama-index-server/llama_index/server/api/models.py#L32) object, which includes the request information that is helpful for initializing the workflow. For example:
-```python
-def create_workflow(chat_request: ChatRequest) -> Workflow:
-    # using messages from the chat request to initialize the workflow
-    return MyCustomWorkflow(chat_request.messages)
-```
-
-Your workflow will be executed once for each chat request with the following input parameters are included in workflow's `StartEvent`:
- `user_msg` [str]: The current user message
- `chat_history` [list[[ChatMessage](https://docs.llamaindex.ai/en/stable/api_reference/prompts/#llama_index.core.prompts.ChatMessage)]]: All the previous messages of the conversation
-
-Example:
-```python
-@step
-def handle_start_event(ev: StartEvent) -> MyNextEvent:
-    user_msg = ev.user_msg
-    chat_history = ev.chat_history
-    ...
-```
-
-Your workflows can emit `UIEvent` events to render [Custom UI Components](https://github.com/run-llama/create-llama/blob/main/python/llama-index-server/docs/custom_ui_component.md) in the chat UI to improve the user experience.
-Furthermore, you can send `ArtifactEvent` events to render code or document [Artifacts](https://github.com/run-llama/create-llama/blob/main/python/llama-index-server/docs/custom_artifact_event.md) in a dedicated Canvas panel in the chat UI.
-
 ## Default Routers and Features

 ### Chat Router
@@ -135,6 +107,11 @@ When enabled, the server provides a chat interface at the root path (`/`) with:
 - Real-time chat interface
 - API endpoint integration

+### Custom UI Components
+
+You can add custom UI components for your workflow by providing `component_dir` config and adding custom .jsx or .tsx files to the directory.
+See [Custom UI Components](https://github.com/run-llama/create-llama/blob/main/llama-index-server/docs/custom_ui_component.md) for more details.
+
 ## Development Mode

 In development mode (`env="dev"`), the server:
@@ -143,35 +120,21 @@ In development mode (`env="dev"`), the server:
 - Automatically includes the chat UI
 - Provides more verbose logging

-### Workflow Editor (Beta)
-
-In development mode, you can set `dev_mode` to `True` in the UI configuration to enable the workflow editor, which allows you to edit the workflow code directly in the browser.
-
-```python
-app = LlamaIndexServer(
-    workflow_factory=create_workflow,
-    env="dev",
-    ui_config={"dev_mode": True},
-)
-```
-
-**Note**: The workflow editor is currently in beta and only supports updating LlamaIndexServer projects created with [create-llama](https://github.com/run-llama/create-llama/). You also need to start the server via `fastapi dev` so that the server can hot reload the workflow code.
-
 ## API Endpoints

 The server provides the following default endpoints:

 - `/api/chat`: Chat interaction endpoint
- `/api/chat/file`: File upload endpoint (only available when `enable_file_upload` in `ui_config` is True)
 - `/api/files/data/*`: Access to data directory files
 - `/api/files/output/*`: Access to output directory files

 ## Best Practices

-1. Use environment variables for sensitive configuration
-2. Enable verbose logging during development
-3. Configure CORS appropriately for your deployment environment
-4. Use starter questions to guide users in the chat UI
+1. Always provide a workflow factory that creates fresh workflow instances
+2. Use environment variables for sensitive configuration
+3. Enable verbose logging during development
+4. Configure CORS appropriately for your deployment environment
+5. Use starter questions to guide users in the chat UI

 ## Getting Started with a New Project

@@ -1,4 +1,4 @@
-from .models.ui import UIEvent
+from .api.models import UIEvent
 from .server import LlamaIndexServer, UIConfig

 __all__ = ["LlamaIndexServer", "UIConfig", "UIEvent"]
@@ -1,7 +1,3 @@
-from llama_index.server.api.callbacks.agent_call_tool import AgentCallTool
-from llama_index.server.api.callbacks.artifact_transform import (
-    InlineAnnotationTransformer,
-)
 from llama_index.server.api.callbacks.base import EventCallback
 from llama_index.server.api.callbacks.llamacloud import LlamaCloudFileDownload
 from llama_index.server.api.callbacks.source_nodes import SourceNodesFromToolCall
@@ -14,6 +10,4 @@ __all__ = [
    "SourceNodesFromToolCall",
    "SuggestNextQuestions",
    "LlamaCloudFileDownload",
-    "AgentCallTool",
-    "InlineAnnotationTransformer",
 ]
@@ -0,0 +1,32 @@
+from typing import Any
+
+from llama_index.core.agent.workflow.workflow_events import ToolCallResult
+from llama_index.server.api.callbacks.base import EventCallback
+from llama_index.server.api.models import SourceNodesEvent
+
+
+class SourceNodesFromToolCall(EventCallback):
+    """
+    Extract source nodes from the query tool output.
+
+    Args:
+        query_tool_name: The name of the tool that queries the index.
+                         default is "query_index"
+    """
+
+    def __init__(self, query_tool_name: str = "query_index"):
+        self.query_tool_name = query_tool_name
+
+    def transform_tool_call_result(self, event: ToolCallResult) -> SourceNodesEvent:
+        source_nodes = event.tool_output.raw_output.source_nodes
+        return SourceNodesEvent(nodes=source_nodes)
+
+    async def run(self, event: Any) -> Any:
+        if isinstance(event, ToolCallResult):
+            if event.tool_name == self.query_tool_name:
+                return event, self.transform_tool_call_result(event)
+        return event
+
+    @classmethod
+    def from_default(cls, *args: Any, **kwargs: Any) -> "SourceNodesFromToolCall":
+        return cls()
@@ -25,10 +25,6 @@ class StreamHandler:
        """Cancel the workflow handler."""
        await self.workflow_handler.cancel_run()

-    async def wait_for_completion(self) -> Any:
-        """Wait for the workflow to finish."""
-        await self.workflow_handler
-
    async def stream_events(self) -> AsyncGenerator[Any, None]:
        """Stream events through the processor chain."""
        try:
@@ -2,7 +2,7 @@ import logging
 from typing import Any, Optional

 from llama_index.server.api.callbacks.base import EventCallback
-from llama_index.server.models.chat import ChatRequest
+from llama_index.server.api.models import ChatRequest
 from llama_index.server.services.suggest_next_question import (
    SuggestNextQuestionsService,
 )
@@ -0,0 +1,153 @@
+import logging
+import os
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from llama_index.core.schema import NodeWithScore
+from llama_index.core.types import ChatMessage, MessageRole
+from llama_index.core.workflow import Event
+from llama_index.server.settings import server_settings
+from pydantic import BaseModel, Field, field_validator
+
+logger = logging.getLogger("uvicorn")
+
+
+class ChatConfig(BaseModel):
+    next_question_suggestions: bool = Field(
+        default=True,
+        description="Whether to suggest next questions",
+    )
+
+
+class ChatAPIMessage(BaseModel):
+    role: MessageRole
+    content: str
+
+    def to_llamaindex_message(self) -> ChatMessage:
+        return ChatMessage(role=self.role, content=self.content)
+
+
+class ChatRequest(BaseModel):
+    messages: List[ChatAPIMessage]
+    data: Optional[Any] = None
+    config: Optional[ChatConfig] = ChatConfig()
+
+    @field_validator("messages")
+    def validate_messages(cls, v: List[ChatAPIMessage]) -> List[ChatAPIMessage]:
+        if v[-1].role != MessageRole.USER:
+            raise ValueError("Last message must be from user")
+        return v
+
+
+class AgentRunEventType(Enum):
+    TEXT = "text"
+    PROGRESS = "progress"
+
+
+class AgentRunEvent(Event):
+    name: str
+    msg: str
+    event_type: AgentRunEventType = AgentRunEventType.TEXT
+    data: Optional[dict] = None
+
+    def to_response(self) -> dict:
+        return {
+            "type": "agent",
+            "data": {
+                "agent": self.name,
+                "type": self.event_type.value,
+                "text": self.msg,
+                "data": self.data,
+            },
+        }
+
+
+class SourceNodesEvent(Event):
+    nodes: List[NodeWithScore]
+
+    def to_response(self) -> dict:
+        return {
+            "type": "sources",
+            "data": {
+                "nodes": [
+                    SourceNodes.from_source_node(node).model_dump()
+                    for node in self.nodes
+                ]
+            },
+        }
+
+
+class SourceNodes(BaseModel):
+    id: str
+    metadata: Dict[str, Any]
+    score: Optional[float]
+    text: str
+    url: Optional[str]
+
+    @classmethod
+    def from_source_node(cls, source_node: NodeWithScore) -> "SourceNodes":
+        metadata = source_node.node.metadata
+        url = cls.get_url_from_metadata(metadata)
+
+        return cls(
+            id=source_node.node.node_id,
+            metadata=metadata,
+            score=source_node.score,
+            text=source_node.node.text,  # type: ignore
+            url=url,
+        )
+
+    @classmethod
+    def get_url_from_metadata(
+        cls,
+        metadata: Dict[str, Any],
+        data_dir: Optional[str] = None,
+    ) -> Optional[str]:
+        url_prefix = server_settings.file_server_url_prefix
+        if data_dir is None:
+            data_dir = "data"
+        file_name = metadata.get("file_name")
+
+        if file_name and url_prefix:
+            # file_name exists and file server is configured
+            pipeline_id = metadata.get("pipeline_id")
+            if pipeline_id:
+                # file is from LlamaCloud
+                file_name = f"{pipeline_id}${file_name}"
+                return f"{url_prefix}/output/llamacloud/{file_name}"
+            is_private = metadata.get("private", "false") == "true"
+            if is_private:
+                # file is a private upload
+                return f"{url_prefix}/output/uploaded/{file_name}"
+            # file is from calling the 'generate' script
+            # Get the relative path of file_path to data_dir
+            file_path = metadata.get("file_path")
+            data_dir = os.path.abspath(data_dir)
+            if file_path and data_dir:
+                relative_path = os.path.relpath(file_path, data_dir)
+                return f"{url_prefix}/data/{relative_path}"
+        # fallback to URL in metadata (e.g. for websites)
+        return metadata.get("URL")
+
+    @classmethod
+    def from_source_nodes(
+        cls, source_nodes: List[NodeWithScore]
+    ) -> List["SourceNodes"]:
+        return [cls.from_source_node(node) for node in source_nodes]
+
+
+class ComponentDefinition(BaseModel):
+    type: str
+    code: str
+    filename: str
+
+
+class UIEvent(Event):
+    type: str
+    data: BaseModel
+
+    def to_response(self) -> dict:
+        return {
+            "type": self.type,
+            "data": self.data.model_dump(),
+        }
@@ -0,0 +1,4 @@
+from llama_index.server.api.routers.chat import chat_router
+from llama_index.server.api.routers.ui import custom_components_router
+
+__all__ = ["chat_router", "custom_components_router"]
@@ -6,42 +6,24 @@ from typing import AsyncGenerator, Callable, Union

 from fastapi import APIRouter, BackgroundTasks, HTTPException
 from fastapi.responses import StreamingResponse
-from llama_index.core.agent.workflow.workflow_events import (
-    AgentInput,
-    AgentSetup,
-    AgentStream,
-)
-from llama_index.core.workflow import (
-    StopEvent,
-    Workflow,
-)
+
+from llama_index.core.agent.workflow.workflow_events import AgentStream
+from llama_index.core.workflow import StopEvent, Workflow
 from llama_index.server.api.callbacks import (
-    AgentCallTool,
-    EventCallback,
-    InlineAnnotationTransformer,
-    LlamaCloudFileDownload,
    SourceNodesFromToolCall,
    SuggestNextQuestions,
 )
+from llama_index.server.api.callbacks.base import EventCallback
+from llama_index.server.api.callbacks.llamacloud import LlamaCloudFileDownload
 from llama_index.server.api.callbacks.stream_handler import StreamHandler
+from llama_index.server.api.models import ChatRequest
 from llama_index.server.api.utils.vercel_stream import VercelStreamResponse
-from llama_index.server.models.chat import (
-    ChatRequest,
-    FileUpload,
-    MessageRole,
-)
-from llama_index.server.models.file import ServerFileResponse
-from llama_index.server.models.hitl import HumanInputEvent
-from llama_index.server.services.file import FileService
 from llama_index.server.services.llamacloud import LlamaCloudFileService
-from llama_index.server.services.workflow import HITLWorkflowService
-from pydantic_core import PydanticSerializationError


 def chat_router(
    workflow_factory: Callable[..., Workflow],
    logger: logging.Logger,
-    suggest_next_questions: bool = True,
 ) -> APIRouter:
    router = APIRouter(prefix="/chat")

@@ -51,9 +33,7 @@ def chat_router(
        background_tasks: BackgroundTasks,
    ) -> StreamingResponse:
        try:
-            last_message = request.messages[-1]
-            if last_message.role != MessageRole.USER:
-                raise ValueError("Last message must be from user")
+            user_message = request.messages[-1].to_llamaindex_message()
            chat_history = [
                message.to_llamaindex_message() for message in request.messages[:-1]
            ]
@@ -63,29 +43,16 @@ def chat_router(
                workflow = workflow_factory(chat_request=request)
            else:
                workflow = workflow_factory()
-
-            # Check if we should resume a chat with a human response
-            human_response = last_message.human_response
-            if human_response:
-                ctx = await HITLWorkflowService.load_context(
-                    id=request.id,
-                    workflow=workflow,
-                    data=human_response,
-                )
-                workflow_handler = workflow.run(ctx=ctx)
-            else:
-                workflow_handler = workflow.run(
-                    user_msg=last_message.content,
-                    chat_history=chat_history,
-                )
+            workflow_handler = workflow.run(
+                user_msg=user_message.content,
+                chat_history=chat_history,
+            )

            callbacks: list[EventCallback] = [
-                AgentCallTool(),
-                InlineAnnotationTransformer(),
                SourceNodesFromToolCall(),
                LlamaCloudFileDownload(background_tasks),
            ]
-            if suggest_next_questions:
+            if request.config and request.config.next_question_suggestions:
                callbacks.append(SuggestNextQuestions(request))
            stream_handler = StreamHandler(
                workflow_handler=workflow_handler,
@@ -93,31 +60,12 @@ def chat_router(
            )

            return VercelStreamResponse(
-                content_generator=_stream_content(
-                    stream_handler,
-                    logger,
-                    request.id,
-                ),
+                content_generator=_stream_content(stream_handler, request, logger),
            )
        except Exception as e:
            logger.error(e)
            raise HTTPException(status_code=500, detail=str(e))

-    # we just simply save the file to the server and don't index it
-    @router.post("/file")
-    async def upload_file(request: FileUpload) -> ServerFileResponse:
-        """
-        Upload a file to the server to be used in the chat session.
-        """
-        try:
-            save_dir = os.path.join("output", "private")
-            content, _ = FileService._preprocess_base64_file(request.base64)
-            file = FileService.save_file(content, request.name, save_dir)
-            return file.to_server_file_response()
-        except Exception:
-            raise HTTPException(status_code=500, detail="Error uploading file")
-
-    # Specific to LlamaCloud
    if LlamaCloudFileService.is_configured():

        @router.get("/config/llamacloud")
@@ -145,8 +93,8 @@ def chat_router(

 async def _stream_content(
    handler: StreamHandler,
+    request: ChatRequest,
    logger: logging.Logger,
-    chat_id: str,
 ) -> AsyncGenerator[str, None]:
    async def _text_stream(
        event: Union[AgentStream, StopEvent],
@@ -166,45 +114,31 @@ async def _stream_content(
                    elif hasattr(chunk, "delta") and chunk.delta:
                        yield chunk.delta

+    stream_started = False
    try:
        async for event in handler.stream_events():
+            if not stream_started:
+                # Start the stream with an empty message
+                stream_started = True
+                yield VercelStreamResponse.convert_text("")
+
+            # Handle different types of events
            if isinstance(event, (AgentStream, StopEvent)):
                async for chunk in _text_stream(event):
                    handler.accumulate_text(chunk)
                    yield VercelStreamResponse.convert_text(chunk)
-            elif isinstance(event, HumanInputEvent):
-                ctx = handler.workflow_handler.ctx
-                if ctx is None:
-                    raise RuntimeError("Context is None")
-                # Save the context with the HITL event
-                await HITLWorkflowService.save_context(
-                    id=chat_id,
-                    ctx=ctx,
-                    resume_event_type=event.response_event_type,
-                )
-                yield VercelStreamResponse.convert_data(event.to_response())
-                # return to stop the stream
-                return
            elif isinstance(event, dict):
                yield VercelStreamResponse.convert_data(event)
            elif hasattr(event, "to_response"):
                event_response = event.to_response()
                yield VercelStreamResponse.convert_data(event_response)
            else:
-                # Ignore unnecessary agent workflow events
-                if not isinstance(event, (AgentInput, AgentSetup)):
-                    try:
-                        yield VercelStreamResponse.convert_data(event.model_dump())
-                    except PydanticSerializationError:
-                        logger.warning(f"Error serializing event: {event}")
-                        # Skip events that can't be serialized
-                        pass
+                yield VercelStreamResponse.convert_data(event.model_dump())

-        await handler.wait_for_completion()
    except asyncio.CancelledError:
        logger.warning("Client cancelled the request!")
        await handler.cancel_run()
    except Exception as e:
-        logger.error(f"Error in stream response: {e}", exc_info=True)
+        logger.error(f"Error in stream response: {e}")
        yield VercelStreamResponse.convert_error(str(e))
        await handler.cancel_run()
@@ -0,0 +1,20 @@
+import logging
+from typing import List
+
+from fastapi import APIRouter
+from llama_index.server.api.models import ComponentDefinition
+from llama_index.server.services.custom_ui import CustomUI
+
+
+def custom_components_router(
+    component_dir: str,
+    logger: logging.Logger,
+) -> APIRouter:
+    router = APIRouter(prefix="/components")
+
+    @router.get("")
+    async def components() -> List[ComponentDefinition]:
+        custom_ui = CustomUI(component_dir=component_dir, logger=logger)
+        return custom_ui.get_components()
+
+    return router
@@ -0,0 +1,55 @@
+import logging
+import shutil
+from pathlib import Path
+from typing import Optional
+
+import requests
+
+CHAT_UI_VERSION = "0.1.5"
+
+
+def download_chat_ui(
+    logger: Optional[logging.Logger] = None, target_path: str = ".ui"
+) -> None:
+    if logger is None:
+        logger = logging.getLogger("uvicorn")
+    path = Path(target_path)
+    temp_dir = _download_package(_get_download_link(CHAT_UI_VERSION))
+    _copy_ui_files(temp_dir, path)
+    logger.info("Chat UI downloaded and copied to static folder")
+
+
+def _get_download_link(version: str) -> str:
+    """Get the download link for the chat UI from the npm registry."""
+    return f"https://registry.npmjs.org/@llamaindex/server/-/server-{version}.tgz"
+
+
+def _download_package(url: str) -> Path:
+    """Download tar.gz file and extract all files into a temporary directory."""
+    import io
+    import tarfile
+    import tempfile
+
+    response = requests.get(url, headers={"User-Agent": "Mozilla/5.0"})
+    content = response.content
+
+    temp_dir = Path(tempfile.mkdtemp())
+
+    with tarfile.open(fileobj=io.BytesIO(content), mode="r:gz") as tar:
+        tar.extractall(path=temp_dir)
+
+    return temp_dir
+
+
+def _copy_ui_files(temp_dir: Path, target_path: Path) -> None:
+    """Copy files from the .next directory to the static directory."""
+    target_path.mkdir(parents=True, exist_ok=True)
+    next_dir = temp_dir / "package/dist/static"
+
+    if next_dir.exists():
+        for item in next_dir.iterdir():
+            dest = target_path / item.name
+            if item.is_dir():
+                shutil.copytree(item, dest, dirs_exist_ok=True)
+            else:
+                shutil.copy2(item, dest)
@@ -5,22 +5,19 @@ from typing import Any, Callable, Optional, Union

 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.routing import Mount
 from fastapi.staticfiles import StaticFiles
 from llama_index.core.workflow import Workflow
-from llama_index.server.api.routers import (
-    chat_router,
-    custom_components_router,
-    custom_layout_router,
-    dev_router,
-)
-from llama_index.server.chat_ui import copy_bundled_chat_ui
+from llama_index.server.api.routers import chat_router, custom_components_router
+from llama_index.server.chat_ui import download_chat_ui
 from llama_index.server.settings import server_settings
 from pydantic import BaseModel, Field


 class UIConfig(BaseModel):
    enabled: bool = Field(default=True, description="Whether to enable the chat UI")
+    app_title: str = Field(
+        default="LlamaIndex Server", description="The title of the chat UI"
+    )
    starter_questions: Optional[list[str]] = Field(
        default=None, description="The starter questions for the chat UI"
    )
@@ -28,49 +25,25 @@ class UIConfig(BaseModel):
        default=False,
        description="Whether to show the LlamaCloud index selector in the chat UI (need to set the LLAMA_CLOUD_API_KEY environment variable)",
    )
-    enable_file_upload: bool = Field(
-        default=False,
-        description="Whether to enable file upload in the chat UI",
-    )
    ui_path: str = Field(
        default=".ui", description="The path that stores static files for the chat UI"
    )
    component_dir: Optional[str] = Field(
        default=None, description="The directory to custom UI components code"
    )
-    layout_dir: str = Field(
-        default="layout",
-        description="The directory to custom UI layout such as header and footer",
-    )
-    dev_mode: bool = Field(
-        default=False, description="Whether to enable the UI dev mode"
-    )

    def get_config_content(self) -> str:
        return json.dumps(
            {
                "CHAT_API": f"{server_settings.api_url}/chat",
-                "UPLOAD_API": (
-                    f"{server_settings.api_url}/chat/file"
-                    if self.enable_file_upload
-                    else None
-                ),
                "STARTER_QUESTIONS": self.starter_questions or [],
-                "LLAMA_CLOUD_API": (
-                    f"{server_settings.api_url}/chat/config/llamacloud"
-                    if self.llamacloud_index_selector
-                    and os.getenv("LLAMA_CLOUD_API_KEY")
-                    else None
-                ),
-                "COMPONENTS_API": (
-                    f"{server_settings.api_url}/components"
-                    if self.component_dir
-                    else None
-                ),
-                "LAYOUT_API": (
-                    f"{server_settings.api_url}/layout" if self.layout_dir else None
-                ),
-                "DEV_MODE": self.dev_mode,
+                "LLAMA_CLOUD_API": f"{server_settings.api_url}/chat/config/llamacloud"
+                if self.llamacloud_index_selector and os.getenv("LLAMA_CLOUD_API_KEY")
+                else None,
+                "APP_TITLE": self.app_title,
+                "COMPONENTS_API": f"{server_settings.api_url}/components"
+                if self.component_dir
+                else None,
            },
            indent=2,
        )
@@ -85,12 +58,11 @@ class LlamaIndexServer(FastAPI):
        self,
        workflow_factory: Callable[..., Workflow],
        logger: Optional[logging.Logger] = None,
-        use_default_routers: Optional[bool] = None,
+        use_default_routers: Optional[bool] = True,
        env: Optional[str] = None,
        ui_config: Optional[Union[UIConfig, dict]] = None,
        server_url: Optional[str] = None,
        api_prefix: Optional[str] = None,
-        suggest_next_questions: Optional[bool] = None,
        verbose: bool = False,
        *args: Any,
        **kwargs: Any,
@@ -106,7 +78,6 @@ class LlamaIndexServer(FastAPI):
            ui_config: The configuration for the chat UI.
            server_url: The URL of the server.
            api_prefix: The prefix for the API endpoints.
-            suggest_next_questions: Whether to suggest next questions after the assistant's response.
            verbose: Whether to show verbose logs.
        """
        super().__init__(*args, **kwargs)
@@ -114,12 +85,7 @@ class LlamaIndexServer(FastAPI):
        self.workflow_factory = workflow_factory
        self.logger = logger or logging.getLogger("uvicorn")
        self.verbose = verbose
-        self.use_default_routers = (
-            True if use_default_routers is None else use_default_routers
-        )
-        self.suggest_next_questions = (
-            True if suggest_next_questions is None else suggest_next_questions
-        )
+        self.use_default_routers = use_default_routers or True
        if ui_config is None:
            self.ui_config = UIConfig()
        elif isinstance(ui_config, dict):
@@ -132,33 +98,24 @@ class LlamaIndexServer(FastAPI):
            server_settings.set_url(server_url)
        if api_prefix:
            server_settings.set_api_prefix(api_prefix)
-        server_settings.set_workflow_factory(workflow_factory.__name__)
+
+        if self.use_default_routers:
+            self.add_default_routers()

        if str(env).lower() == "dev":
            self.allow_cors("*")
            if self.ui_config.enabled is None:
                self.ui_config.enabled = True
-        else:
-            if self.ui_config.enabled and self.ui_config.dev_mode:
-                raise ValueError(
-                    "UI dev mode requires the environment variable for LlamaIndexServer to be set to 'dev' and start the FastAPI app in dev mode."
-                )
+
        if self.ui_config.enabled is None:
            self.ui_config.enabled = False

-        # Routers
-        if self.use_default_routers:
-            self.add_default_routers()
-
-        # Should mount ui at the end
        if self.ui_config.enabled:
            self.mount_ui()

    # Default routers
    def add_default_routers(self) -> None:
        self.add_chat_router()
-        if self.ui_config.enabled and self.ui_config.dev_mode:
-            self.include_router(dev_router(), prefix=server_settings.api_prefix)
        self.mount_data_dir()
        self.mount_output_dir()

@@ -170,7 +127,6 @@ class LlamaIndexServer(FastAPI):
            chat_router(
                self.workflow_factory,
                self.logger,
-                self.suggest_next_questions,
            ),
            prefix=server_settings.api_prefix,
        )
@@ -187,15 +143,6 @@ class LlamaIndexServer(FastAPI):
            prefix=server_settings.api_prefix,
        )

-    def add_layout_router(self) -> None:
-        """
-        Add the layout router.
-        """
-        self.include_router(
-            custom_layout_router(self.ui_config.layout_dir, self.logger),
-            prefix=server_settings.api_prefix,
-        )
-
    def mount_ui(self) -> None:
        """
        Mount the UI.
@@ -207,25 +154,15 @@ class LlamaIndexServer(FastAPI):
                if not os.path.exists(self.ui_config.component_dir):
                    os.makedirs(self.ui_config.component_dir)
                self.add_components_router()
-            # Layout dir
-            if self.ui_config.layout_dir:
-                if not os.path.exists(self.ui_config.layout_dir):
-                    os.makedirs(self.ui_config.layout_dir)
-                self.add_layout_router()
            # UI static files
            if not os.path.exists(self.ui_config.ui_path):
                os.makedirs(self.ui_config.ui_path)
                self.logger.warning(
-                    f"UI files not found at {self.ui_config.ui_path}. Copying bundled UI files."
-                )
-                copy_bundled_chat_ui(
-                    logger=self.logger, target_path=self.ui_config.ui_path
+                    f"UI files not found, downloading UI to {self.ui_config.ui_path}"
                )
+                download_chat_ui(logger=self.logger, target_path=self.ui_config.ui_path)
            self._mount_static_files(
-                directory=self.ui_config.ui_path,
-                path="/",
-                html=True,
-                name=self.ui_config.ui_path,
+                directory=self.ui_config.ui_path, path="/", html=True
            )
            self._override_ui_config()

@@ -267,11 +204,7 @@ class LlamaIndexServer(FastAPI):
        )

    def _mount_static_files(
-        self,
-        directory: str,
-        path: str,
-        html: bool = False,
-        name: Optional[str] = None,
+        self, directory: str, path: str, html: bool = False
    ) -> None:
        """
        Mount static files from a directory if it exists.
@@ -281,7 +214,7 @@ class LlamaIndexServer(FastAPI):
            self.mount(
                path,
                StaticFiles(directory=directory, check_dir=False, html=html),
-                name=name or f"{directory}-static",
+                name=f"{directory}-static",
            )

    def allow_cors(self, origin: str = "*") -> None:
@@ -295,19 +228,3 @@ class LlamaIndexServer(FastAPI):
            allow_methods=["*"],
            allow_headers=["*"],
        )
-
-    def add_api_route(self, *args: Any, **kwargs: Any) -> None:
-        """
-        Add an API route to the server.
-        """
-        # Because static files are mounted at the root path by default,
-        # we need to place them at the end of the routes list.
-        ui_route = None
-        for route in self.routes:
-            if isinstance(route, Mount):
-                if route.name == self.ui_config.ui_path:
-                    ui_route = route
-                    self.routes.remove(route)
-        super().add_api_route(*args, **kwargs)
-        if ui_route:
-            self.mount(ui_route.path, ui_route.app, name=ui_route.name)
@@ -2,32 +2,35 @@ import logging
 import os
 from typing import List, Optional

-from llama_index.server.models.ui import ComponentDefinition
+from llama_index.server.api.models import ComponentDefinition


 class CustomUI:
-    def __init__(self, logger: Optional[logging.Logger] = None) -> None:
+    def __init__(
+        self, component_dir: str, logger: Optional[logging.Logger] = None
+    ) -> None:
+        self.component_dir = component_dir
        self.logger = logger or logging.getLogger(__name__)

-    def get_components(
-        self, directory: str, filter_types: Optional[List[str]] = None
-    ) -> List[ComponentDefinition]:
+    def get_components(self) -> List[ComponentDefinition]:
        """
        List all js files in the component directory and return a list of ComponentDefinition objects.
        Ignores files that fail to load and logs the error.
        TSX files take precedence over JSX files when duplicate component names are found.
        """
        components_dict: dict[str, ComponentDefinition] = {}
-        if not os.path.exists(directory):
-            self.logger.warning(f"Component directory {directory} does not exist")
+        if not os.path.exists(self.component_dir):
+            self.logger.warning(
+                f"Component directory {self.component_dir} does not exist"
+            )
            return []
        try:
-            for file in os.listdir(directory):
+            for file in os.listdir(self.component_dir):
                if not file.endswith((".jsx", ".tsx")):
                    continue

                component_name = file.split(".")[0]
-                file_path = os.path.join(directory, file)
+                file_path = os.path.join(self.component_dir, file)
                file_ext = os.path.splitext(file)[1]

                try:
@@ -75,11 +78,4 @@ class CustomUI:
        except Exception as e:
            self.logger.error(f"Error reading component directory: {str(e)}")

-        result = list(components_dict.values())
-
-        if filter_types:
-            result = [
-                component for component in result if component.type in filter_types
-            ]
-
-        return result
+        return list(components_dict.values())
@@ -0,0 +1,117 @@
+import logging
+import os
+import re
+import uuid
+from pathlib import Path
+from typing import List, Optional, Union
+
+from llama_index.server.settings import server_settings
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+PRIVATE_STORE_PATH = str(Path("output", "uploaded"))
+TOOL_STORE_PATH = str(Path("output", "tools"))
+LLAMA_CLOUD_STORE_PATH = str(Path("output", "llamacloud"))
+
+
+class DocumentFile(BaseModel):
+    id: str
+    name: str  # Stored file name
+    type: Optional[str] = None
+    size: Optional[int] = None
+    url: Optional[str] = None
+    path: Optional[str] = Field(
+        None,
+        description="The stored file path. Used internally in the server.",
+        exclude=True,
+    )
+    refs: Optional[List[str]] = Field(
+        None, description="The document ids in the index."
+    )
+
+
+class FileService:
+    """
+    To store the files uploaded by the user.
+    """
+
+    @classmethod
+    def save_file(
+        cls,
+        content: Union[bytes, str],
+        file_name: str,
+        save_dir: Optional[str] = None,
+    ) -> DocumentFile:
+        """
+        Save the content to a file in the local file server (accessible via URL).
+
+        Args:
+            content (bytes | str): The content to save, either bytes or string.
+            file_name (str): The original name of the file.
+            save_dir (Optional[str]): The relative path from the current working directory. Defaults to the `output/uploaded` directory.
+
+        Returns:
+            The metadata of the saved file.
+        """
+        if save_dir is None:
+            save_dir = os.path.join("output", "uploaded")
+
+        file_id = str(uuid.uuid4())
+        name, extension = os.path.splitext(file_name)
+        extension = extension.lstrip(".")
+        sanitized_name = _sanitize_file_name(name)
+        if extension == "":
+            raise ValueError("File is not supported!")
+        new_file_name = f"{sanitized_name}_{file_id}.{extension}"
+
+        file_path = os.path.join(save_dir, new_file_name)
+
+        if isinstance(content, str):
+            content = content.encode()
+
+        try:
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+            with open(file_path, "wb") as file:
+                file.write(content)
+        except PermissionError as e:
+            logger.error(f"Permission denied when writing to file {file_path}: {e!s}")
+            raise
+        except OSError as e:
+            logger.error(f"IO error occurred when writing to file {file_path}: {e!s}")
+            raise
+        except Exception as e:
+            logger.error(f"Unexpected error when writing to file {file_path}: {e!s}")
+            raise
+
+        logger.info(f"Saved file to {file_path}")
+
+        file_size = os.path.getsize(file_path)
+        file_url = (
+            f"{server_settings.file_server_url_prefix}/{save_dir}/{new_file_name}"
+        )
+        return DocumentFile(
+            id=file_id,
+            name=new_file_name,
+            type=extension,
+            size=file_size,
+            path=file_path,
+            url=file_url,
+            refs=None,
+        )
+
+    @classmethod
+    def get_file_url(cls, file_name: str, save_dir: Optional[str] = None) -> str:
+        """
+        Get the URL of a file.
+        """
+        if save_dir is None:
+            save_dir = os.path.join("output", "uploaded")
+        return f"{server_settings.file_server_url_prefix}/{save_dir}/{file_name}"
+
+
+def _sanitize_file_name(file_name: str) -> str:
+    """
+    Sanitize the file name by replacing all non-alphanumeric characters with underscores.
+    """
+    return re.sub(r"[^a-zA-Z0-9.]", "_", file_name)
@@ -8,12 +8,10 @@ from typing import Any, Dict, List, Optional, Set, Tuple, Union
 import requests
 from fastapi import BackgroundTasks
 from llama_cloud import ManagedIngestionStatus, PipelineFileCreateCustomMetadataValue
-from pydantic import BaseModel
-
 from llama_index.core.schema import NodeWithScore
-from llama_index.server.models.source_nodes import SourceNodes
+from llama_index.server.api.models import SourceNodes
 from llama_index.server.services.llamacloud.index import get_client
-from llama_index.server.utils import llamacloud
+from pydantic import BaseModel

 logger = logging.getLogger("uvicorn")

@@ -35,6 +33,7 @@ class LlamaCloudFile(BaseModel):

 class LlamaCloudFileService:
    LOCAL_STORE_PATH = "output/llamacloud"
+    DOWNLOAD_FILE_NAME_TPL = "{pipeline_id}${filename}"

    @classmethod
    def get_all_projects_with_pipelines(cls) -> List[Dict[str, Any]]:
@@ -156,12 +155,13 @@ class LlamaCloudFileService:
        # Remove duplicates and return
        return set(llama_cloud_files)

+    @classmethod
+    def _get_file_name(cls, name: str, pipeline_id: str) -> str:
+        return cls.DOWNLOAD_FILE_NAME_TPL.format(pipeline_id=pipeline_id, filename=name)
+
    @classmethod
    def _get_file_path(cls, name: str, pipeline_id: str) -> str:
-        file_name = llamacloud.get_local_file_name(
-            llamacloud_file_name=name, pipeline_id=pipeline_id
-        )
-        return os.path.join(cls.LOCAL_STORE_PATH, file_name)
+        return os.path.join(cls.LOCAL_STORE_PATH, cls._get_file_name(name, pipeline_id))

    @classmethod
    def _download_file(cls, url: str, local_file_path: str) -> None:
@@ -3,15 +3,14 @@ import os
 from typing import TYPE_CHECKING, Any, Optional

 from llama_cloud import PipelineType
-from pydantic import BaseModel, Field, field_validator
-
 from llama_index.core.callbacks import CallbackManager
 from llama_index.core.ingestion.api_utils import (
    get_client as llama_cloud_get_client,
 )
 from llama_index.core.settings import Settings
 from llama_index.indices.managed.llama_cloud import LlamaCloudIndex
-from llama_index.server.models.chat import ChatRequest
+from llama_index.server.api.models import ChatRequest
+from pydantic import BaseModel, Field, field_validator

 if TYPE_CHECKING:
    from llama_cloud.client import LlamaCloud
@@ -92,14 +91,14 @@ class IndexConfig(BaseModel):
    def from_default(cls, chat_request: Optional[ChatRequest] = None) -> "IndexConfig":
        default_config = cls()
        if chat_request is not None and chat_request.data is not None:
-            llamacloud_config = chat_request.data.llama_cloud_pipeline
+            llamacloud_config = chat_request.data.get("llamaCloudPipeline")
            if llamacloud_config is not None:
-                default_config.llama_cloud_pipeline_config.pipeline = (
-                    llamacloud_config.pipeline
-                )
-                default_config.llama_cloud_pipeline_config.project = (
-                    llamacloud_config.project
-                )
+                default_config.llama_cloud_pipeline_config.pipeline = llamacloud_config[
+                    "pipeline"
+                ]
+                default_config.llama_cloud_pipeline_config.project = llamacloud_config[
+                    "project"
+                ]
        return default_config


@@ -5,8 +5,7 @@ from typing import List, Optional, Union

 from llama_index.core.prompts import PromptTemplate
 from llama_index.core.settings import Settings
-from llama_index.server.models.chat import ChatAPIMessage
-from llama_index.server.prompts import SUGGEST_NEXT_QUESTION_PROMPT
+from llama_index.server.api.models import ChatAPIMessage

 logger = logging.getLogger("uvicorn")

@@ -16,11 +15,28 @@ class SuggestNextQuestionsService:
    Suggest the next questions that user might ask based on the conversation history.
    """

+    prompt = PromptTemplate(
+        r"""
+You're a helpful assistant! Your task is to suggest the next questions that user might interested in to keep the conversation going.
+Here is the conversation history
+---------------------
+{conversation}
+---------------------
+Given the conversation history, please give me 3 questions that user might ask next!
+Your answer should be wrapped in three sticks without any index numbers and follows the following format:
+\`\`\`
+<question 1>
+<question 2>
+<question 3>
+\`\`\`
+"""
+    )
+
    @classmethod
    def get_configured_prompt(cls) -> PromptTemplate:
        prompt = os.getenv("NEXT_QUESTION_PROMPT", None)
        if not prompt:
-            return PromptTemplate(SUGGEST_NEXT_QUESTION_PROMPT)
+            return cls.prompt
        return PromptTemplate(prompt)

    @classmethod
@@ -11,10 +11,6 @@ class ServerSettings(BaseSettings):
        default="/api",
        description="The prefix for the API endpoints",
    )
-    workflow_factory_signature: str = Field(
-        default="",
-        description="The signature of the workflow factory function",
-    )

    @property
    def file_server_url_prefix(self) -> str:
@@ -44,9 +40,6 @@ class ServerSettings(BaseSettings):
        self.api_prefix = v
        self.validate_api_prefix(v)  # type: ignore

-    def set_workflow_factory(self, v: str) -> None:
-        self.workflow_factory_signature = v
-
    class Config:
        env_file_encoding = "utf-8"

@@ -0,0 +1,3 @@
+from .query import get_query_engine_tool
+
+__all__ = ["get_query_engine_tool"]
@@ -1,12 +1,9 @@
-import logging
 import os
 from typing import Any, Optional

 from llama_index.core.base.base_query_engine import BaseQueryEngine
-from llama_index.core.indices.base import BaseIndex
 from llama_index.core.tools.query_engine import QueryEngineTool
-
-logger = logging.getLogger(__name__)
+from llama_index.core.indices.base import BaseIndex


 def create_query_engine(index: BaseIndex, **kwargs: Any) -> BaseQueryEngine:
@@ -41,11 +38,12 @@ def get_query_engine_tool(
    if name is None:
        name = "query_index"
    if description is None:
-        description = "Use this tool to retrieve information from a knowledge base. Provide a specific query and can call the tool multiple times if necessary."
+        description = (
+            "Use this tool to retrieve information about the text corpus from an index."
+        )
    query_engine = create_query_engine(index, **kwargs)
-    tool = QueryEngineTool.from_defaults(
+    return QueryEngineTool.from_defaults(
        query_engine=query_engine,
        name=name,
        description=description,
    )
-    return tool
@@ -4,11 +4,9 @@ import os
 import uuid
 from typing import Any, List, Optional

-from pydantic import BaseModel
-
 from llama_index.core.tools import FunctionTool
-from llama_index.server.models.file import ServerFile
-from llama_index.server.services.file import FileService
+from llama_index.server.services.file import DocumentFile, FileService
+from pydantic import BaseModel

 logger = logging.getLogger("uvicorn")

@@ -89,7 +87,7 @@ class E2BCodeInterpreter:
                        self.interpreter.files.write(file_path, content)
            logger.info(f"Uploaded {len(sandbox_files)} files to sandbox")

-    def _save_to_disk(self, base64_data: str, ext: str) -> ServerFile:
+    def _save_to_disk(self, base64_data: str, ext: str) -> DocumentFile:
        buffer = base64.b64decode(base64_data)

        # Output from e2b doesn't have a name. Create a random name for it.
@@ -119,7 +117,7 @@ class E2BCodeInterpreter:
                    output.append(
                        InterpreterExtraResult(
                            type=ext,
-                            filename=document_file.id,
+                            filename=document_file.name,
                            url=document_file.url,
                        )
                    )
@@ -14,7 +14,7 @@ from llama_index.core.tools import (
    ToolSelection,
 )
 from llama_index.core.workflow import Context
-from llama_index.server.models.ui import AgentRunEvent, AgentRunEventType
+from llama_index.server.api.models import AgentRunEvent, AgentRunEventType
 from llama_index.core.agent.workflow.workflow_events import ToolCall, ToolCallResult

 logger = logging.getLogger("uvicorn")
@@ -0,0 +1,65 @@
+[build-system]
+build-backend = "poetry.core.masonry.api"
+requires = ["poetry-core"]
+
+[tool.codespell]
+check-filenames = true
+check-hidden = true
+# Feel free to un-skip examples, and experimental, you will just need to
+# work through many typos (--write-changes and --interactive will help)
+skip = "*.csv,*.html,*.json,*.jsonl,*.pdf,*.txt,*.ipynb"
+
+[tool.mypy]
+disallow_untyped_defs = true
+# Remove venv skip when integrated with pre-commit
+exclude = ["_static", "build", "examples", "notebooks", "venv"]
+ignore_missing_imports = true
+namespace_packages = true
+explicit_package_bases = true
+python_version = "3.10"
+
+[tool.poetry]
+authors = ["Your Name <you@example.com>"]
+description = "llama-index fastapi server"
+exclude = ["**/BUILD"]
+license = "MIT"
+name = "llama-index-server"
+packages = [{include = "llama_index/"}]
+readme = "README.md"
+version = "0.1.14"
+
+[tool.poetry.dependencies]
+python = ">=3.9,<4.0"
+fastapi = {extras = ["standard"], version = "^0.115.11"}
+cachetools = "^5.5.2"
+requests = "^2.32.3"
+pydantic-settings = "^2.8.1"
+llama-index-core = "^0.12.28"
+llama-index-readers-file = "^0.4.6"
+llama-index-indices-managed-llama-cloud = "0.6.3"
+
+[tool.poetry.group.dev.dependencies]
+black = {extras = ["jupyter"], version = "<=23.9.1,>=23.7.0"}
+codespell = {extras = ["toml"], version = ">=v2.2.6"}
+e2b-code-interpreter = "^1.1.1"
+ipython = "8.10.0"
+jupyter = "^1.0.0"
+markdown = "^3.7"
+mypy = "1.15.0"
+pre-commit = "3.2.0"
+pylint = "2.15.10"
+pytest = "^8.3.5"
+pytest-asyncio = "^0.25.3"
+pytest-mock = "3.11.1"
+ruff = "0.0.292"
+tree-sitter-languages = "^1.8.0"
+types-Deprecated = ">=0.1.0"
+types-PyYAML = "^6.0.12.12"
+types-protobuf = "^4.24.0.4"
+types-redis = "4.5.5.0"
+types-requests = "2.28.11.8"  # TODO: unpin when mypy>0.991
+types-setuptools = "67.1.0.0"
+xhtml2pdf = "^0.2.17"
+pytest-cov = "^6.0.0"
+llama-cloud = "^0.1.17"
+
@@ -1,5 +1,4 @@
 import logging
-from typing import AsyncGenerator, Callable
 from unittest.mock import AsyncMock, MagicMock

 import pytest
@@ -8,32 +7,31 @@ from httpx import ASGITransport, AsyncClient

 from llama_index.core.workflow import StopEvent, Workflow
 from llama_index.core.workflow.handler import WorkflowHandler
+from llama_index.server.api.models import ChatAPIMessage, ChatRequest
 from llama_index.server.api.routers.chat import chat_router
-from llama_index.server.models.chat import ChatAPIMessage, ChatRequest, MessageRole


@pytest.fixture()
-def logger() -> logging.Logger:
+def logger():
    return logging.getLogger("test")


@pytest.fixture()
-def chat_request() -> ChatRequest:
+def chat_request():
    """Create a simple chat request with one user message."""
    return ChatRequest(
-        id="test",
-        messages=[ChatAPIMessage(role=MessageRole.USER, content="Hello, how are you?")],
+        messages=[ChatAPIMessage(role="user", content="Hello, how are you?")]
    )


@pytest.fixture()
-def mock_workflow() -> MagicMock:
+def mock_workflow():
    """Create a mock workflow that returns a simple response."""
    workflow = MagicMock(spec=Workflow)
    handler = AsyncMock(spec=WorkflowHandler)

    # Setup the handler to stream a simple response event
-    async def mock_stream_events() -> AsyncGenerator[StopEvent, None]:
+    async def mock_stream_events():
        yield StopEvent(result="I'm doing well, thank you for asking!")

    handler.stream_events.return_value = mock_stream_events()
@@ -43,21 +41,17 @@ def mock_workflow() -> MagicMock:


@pytest.fixture()
-def workflow_factory(mock_workflow: MagicMock) -> Callable[[], MagicMock]:
+def workflow_factory(mock_workflow):
    """Create a factory function that returns our mock workflow."""

-    def factory(verbose: bool = False) -> MagicMock:
+    def factory(verbose=False):
        return mock_workflow

    return factory


@pytest.mark.asyncio()
-async def test_chat_router(
-    chat_request: ChatRequest,
-    workflow_factory: Callable[[], MagicMock],
-    logger: logging.Logger,
-) -> None:
+async def test_chat_router(chat_request, workflow_factory, logger):
    """Test that the chat router handles a request correctly."""
    # Create a FastAPI app and mount our router
    app = FastAPI()
@@ -90,19 +84,20 @@ async def test_chat_router(

        # Verify the workflow was called with the correct arguments
        call_args = mock_workflow.run.call_args[1]
+        assert call_args["user_msg"] == "Hello, how are you?"
        assert isinstance(call_args["chat_history"], list)
        assert len(call_args["chat_history"]) == 0  # No history for first message


@pytest.mark.asyncio()
-async def test_chat_with_agent_workflow(logger: logging.Logger) -> None:
+async def test_chat_with_agent_workflow(logger):
    """Test that the chat router works with a workflow that mimics an agent workflow."""
    # Create a simple workflow that mimics an agent workflow
    mock_workflow = MagicMock(spec=Workflow)
    handler = AsyncMock(spec=WorkflowHandler)

    # Setup the handler to stream a simple response about weather
-    async def mock_stream_events() -> AsyncGenerator[StopEvent, None]:
+    async def mock_stream_events():
        yield StopEvent(
            result="The weather in New York is sunny. I used the weather tool to get this information."
        )
@@ -111,7 +106,7 @@ async def test_chat_with_agent_workflow(logger: logging.Logger) -> None:
    mock_workflow.run.return_value = handler

    # Create a factory function that returns our mock workflow
-    def workflow_factory(verbose: bool = False) -> MagicMock:
+    def workflow_factory(verbose=False):
        return mock_workflow

    # Create a FastAPI app and mount our router
@@ -121,12 +116,9 @@ async def test_chat_with_agent_workflow(logger: logging.Logger) -> None:

    # Create a chat request asking about weather
    chat_request = ChatRequest(
-        id="test",
        messages=[
-            ChatAPIMessage(
-                role=MessageRole.USER, content="What's the weather in New York?"
-            )
-        ],
+            ChatAPIMessage(role="user", content="What's the weather in New York?")
+        ]
    )

    # Make a request to the chat endpoint
@@ -152,5 +144,6 @@ async def test_chat_with_agent_workflow(logger: logging.Logger) -> None:

        # Verify the workflow was called with the correct arguments
        call_args = mock_workflow.run.call_args[1]
+        assert call_args["user_msg"] == "What's the weather in New York?"
        assert isinstance(call_args["chat_history"], list)
        assert len(call_args["chat_history"]) == 0  # No history for first message
@@ -1,48 +1,39 @@
 import asyncio
 import logging
-from typing import Any, AsyncGenerator
 from unittest.mock import AsyncMock, MagicMock

 import pytest

 from llama_index.core.agent.workflow.workflow_events import AgentStream
-from llama_index.core.types import MessageRole
 from llama_index.core.workflow import StopEvent
 from llama_index.core.workflow.handler import WorkflowHandler
+from llama_index.server.api.models import ChatAPIMessage, ChatRequest
 from llama_index.server.api.routers.chat import _stream_content
 from llama_index.server.api.utils.vercel_stream import VercelStreamResponse
-from llama_index.server.models.chat import ChatAPIMessage, ChatRequest


@pytest.fixture()
-def logger() -> logging.Logger:
+def logger():
    return logging.getLogger("test")


@pytest.fixture()
-def chat_request() -> ChatRequest:
-    return ChatRequest(
-        id="test",
-        messages=[ChatAPIMessage(role=MessageRole.USER, content="test message")],
-    )
+def chat_request():
+    return ChatRequest(messages=[ChatAPIMessage(role="user", content="test message")])


@pytest.fixture()
-def mock_workflow_handler() -> AsyncMock:
+def mock_workflow_handler():
    handler = AsyncMock(spec=WorkflowHandler)
    handler.accumulate_text = MagicMock()
-    handler.wait_for_completion = AsyncMock()
    return handler


 class TestEventStream:
    @pytest.mark.asyncio()
    async def test_stream_content_with_agent_stream(
-        self,
-        mock_workflow_handler: AsyncMock,
-        chat_request: ChatRequest,
-        logger: logging.Logger,
-    ) -> None:
+        self, mock_workflow_handler, chat_request, logger
+    ):
        # Setup
        mock_workflow_handler.stream_events.return_value = (
            self._mock_agent_stream_events()
@@ -52,22 +43,20 @@ class TestEventStream:
        result = [
            chunk
            async for chunk in _stream_content(
-                mock_workflow_handler, logger, chat_request.id
+                mock_workflow_handler, chat_request, logger
            )
        ]

        # Assert
-        assert len(result) == 2
-        assert result[0] == VercelStreamResponse.convert_text("Hello")
-        assert result[1] == VercelStreamResponse.convert_text(" World")
+        assert len(result) == 3  # Empty start + 2 text chunks
+        assert result[0] == VercelStreamResponse.convert_text("")
+        assert result[1] == VercelStreamResponse.convert_text("Hello")
+        assert result[2] == VercelStreamResponse.convert_text(" World")

    @pytest.mark.asyncio()
    async def test_stream_content_with_stop_event_string(
-        self,
-        mock_workflow_handler: AsyncMock,
-        chat_request: ChatRequest,
-        logger: logging.Logger,
-    ) -> None:
+        self, mock_workflow_handler, chat_request, logger
+    ):
        # Setup
        mock_workflow_handler.stream_events.return_value = (
            self._mock_stop_event_string()
@@ -77,21 +66,19 @@ class TestEventStream:
        result = [
            chunk
            async for chunk in _stream_content(
-                mock_workflow_handler, logger, chat_request.id
+                mock_workflow_handler, chat_request, logger
            )
        ]

        # Assert
-        assert len(result) == 1
-        assert result[0] == VercelStreamResponse.convert_text("Final answer")
+        assert len(result) == 2  # Empty start + result string
+        assert result[0] == VercelStreamResponse.convert_text("")
+        assert result[1] == VercelStreamResponse.convert_text("Final answer")

    @pytest.mark.asyncio()
    async def test_stream_content_with_stop_event_delta_objects(
-        self,
-        mock_workflow_handler: AsyncMock,
-        chat_request: ChatRequest,
-        logger: logging.Logger,
-    ) -> None:
+        self, mock_workflow_handler, chat_request, logger
+    ):
        # Setup
        mock_workflow_handler.stream_events.return_value = (
            self._mock_stop_event_delta_objects()
@@ -101,22 +88,20 @@ class TestEventStream:
        result = [
            chunk
            async for chunk in _stream_content(
-                mock_workflow_handler, logger, chat_request.id
+                mock_workflow_handler, chat_request, logger
            )
        ]

        # Assert
-        assert len(result) == 2
-        assert result[0] == VercelStreamResponse.convert_text("Delta 1")
-        assert result[1] == VercelStreamResponse.convert_text("Delta 2")
+        assert len(result) == 3  # Empty start + 2 delta chunks
+        assert result[0] == VercelStreamResponse.convert_text("")
+        assert result[1] == VercelStreamResponse.convert_text("Delta 1")
+        assert result[2] == VercelStreamResponse.convert_text("Delta 2")

    @pytest.mark.asyncio()
    async def test_stream_content_with_event_with_to_response(
-        self,
-        mock_workflow_handler: AsyncMock,
-        chat_request: ChatRequest,
-        logger: logging.Logger,
-    ) -> None:
+        self, mock_workflow_handler, chat_request, logger
+    ):
        # Setup
        mock_workflow_handler.stream_events.return_value = (
            self._mock_event_with_to_response()
@@ -126,21 +111,19 @@ class TestEventStream:
        result = [
            chunk
            async for chunk in _stream_content(
-                mock_workflow_handler, logger, chat_request.id
+                mock_workflow_handler, chat_request, logger
            )
        ]

        # Assert
-        assert len(result) == 1
-        assert result[0] == VercelStreamResponse.convert_data({"event_type": "test"})
+        assert len(result) == 2  # Empty start + event with to_response
+        assert result[0] == VercelStreamResponse.convert_text("")
+        assert result[1] == VercelStreamResponse.convert_data({"event_type": "test"})

    @pytest.mark.asyncio()
    async def test_stream_content_with_event_with_model_dump(
-        self,
-        mock_workflow_handler: AsyncMock,
-        chat_request: ChatRequest,
-        logger: logging.Logger,
-    ) -> None:
+        self, mock_workflow_handler, chat_request, logger
+    ):
        # Setup
        mock_workflow_handler.stream_events.return_value = (
            self._mock_event_with_model_dump()
@@ -150,30 +133,28 @@ class TestEventStream:
        result = [
            chunk
            async for chunk in _stream_content(
-                mock_workflow_handler, logger, chat_request.id
+                mock_workflow_handler, chat_request, logger
            )
        ]

        # Assert
-        assert len(result) == 1
-        assert result[0] == VercelStreamResponse.convert_data(None)  # type: ignore
+        assert len(result) == 2  # Empty start + event with model_dump
+        assert result[0] == VercelStreamResponse.convert_text("")
+        assert result[1] == VercelStreamResponse.convert_data(None)

    @pytest.mark.asyncio()
    async def test_stream_content_with_cancelled_error(
-        self,
-        mock_workflow_handler: AsyncMock,
-        chat_request: ChatRequest,
-        logger: logging.Logger,
-    ) -> None:
+        self, mock_workflow_handler, chat_request, logger
+    ):
        # Setup
        mock_workflow_handler.stream_events.side_effect = asyncio.CancelledError()
-        logger.warning = MagicMock()  # type: ignore
+        logger.warning = MagicMock()

        # Execute
        result = [
            chunk
            async for chunk in _stream_content(
-                mock_workflow_handler, logger, chat_request.id
+                mock_workflow_handler, chat_request, logger
            )
        ]

@@ -184,21 +165,18 @@ class TestEventStream:

    @pytest.mark.asyncio()
    async def test_stream_content_with_exception(
-        self,
-        mock_workflow_handler: AsyncMock,
-        chat_request: ChatRequest,
-        logger: logging.Logger,
-    ) -> None:
+        self, mock_workflow_handler, chat_request, logger
+    ):
        # Setup
        error_message = "Test error"
        mock_workflow_handler.stream_events.side_effect = Exception(error_message)
-        logger.error = MagicMock()  # type: ignore
+        logger.error = MagicMock()

        # Execute
        result = [
            chunk
            async for chunk in _stream_content(
-                mock_workflow_handler, logger, chat_request.id
+                mock_workflow_handler, chat_request, logger
            )
        ]

@@ -208,7 +186,7 @@ class TestEventStream:
        mock_workflow_handler.cancel_run.assert_called_once()
        logger.error.assert_called_once()

-    async def _mock_agent_stream_events(self) -> AsyncGenerator[AgentStream, Any]:
+    async def _mock_agent_stream_events(self):
        yield AgentStream(
            delta="Hello", response="", current_agent_name="", tool_calls=[], raw=""
        )
@@ -216,9 +194,7 @@ class TestEventStream:
            delta=" World", response="", current_agent_name="", tool_calls=[], raw=""
        )

-    async def _mock_agent_stream_with_empty_deltas(
-        self,
-    ) -> AsyncGenerator[AgentStream, Any]:
+    async def _mock_agent_stream_with_empty_deltas(self):
        yield AgentStream(
            delta="   ",  # Empty delta with spaces - should be filtered
            response="",
@@ -241,14 +217,14 @@ class TestEventStream:
            raw="",
        )

-    async def _mock_stop_event_string(self) -> AsyncGenerator[StopEvent, Any]:
+    async def _mock_stop_event_string(self):
        yield StopEvent(result="Final answer")

-    async def _mock_stop_event_delta_objects(self) -> AsyncGenerator[StopEvent, Any]:
-        async def generator() -> AsyncGenerator[Any, Any]:
+    async def _mock_stop_event_delta_objects(self):
+        async def generator():
            # Create proper objects with delta attribute that can be serialized
            class ObjectWithDelta:
-                def __init__(self, delta_value: str) -> None:
+                def __init__(self, delta_value) -> None:
                    self.delta = delta_value

            yield ObjectWithDelta("Delta 1")
@@ -256,15 +232,15 @@ class TestEventStream:

        yield StopEvent(result=generator())

-    async def _mock_dict_event(self) -> AsyncGenerator[dict[Any, Any], Any]:
+    async def _mock_dict_event(self):
        yield {"key": "value"}

-    async def _mock_event_with_to_response(self) -> AsyncGenerator[Any, Any]:
+    async def _mock_event_with_to_response(self):
        event = MagicMock()
        event.to_response.return_value = {"event_type": "test"}
        yield event

-    async def _mock_event_with_model_dump(self) -> AsyncGenerator[Any, Any]:
+    async def _mock_event_with_model_dump(self):
        event = MagicMock()
        event.model_dump.return_value = {"name": "test_event"}
        # Override to_response to return None - this means convert_data(None) will be called
@@ -1,24 +1,35 @@
 import os
 import uuid
-from unittest.mock import MagicMock, mock_open, patch
+from unittest.mock import mock_open, patch

 import pytest
-
-from llama_index.server.services.file import FileService
+from llama_index.server.services.file import FileService, _sanitize_file_name


 class TestFileService:
+    def test_sanitize_file_name(self):
+        # Test with normal alphanumeric name
+        assert _sanitize_file_name("test123") == "test123"
+
+        # Test with spaces
+        assert _sanitize_file_name("test file") == "test_file"
+
+        # Test with special characters
+        assert _sanitize_file_name("test@file!name") == "test_file_name"
+
+        # Test with path-like characters
+        assert _sanitize_file_name("test/file/name") == "test_file_name"
+
+        # Test with dots (should be preserved)
+        assert _sanitize_file_name("test.file.name") == "test.file.name"
+
    @patch("uuid.uuid4")
    @patch("os.path.getsize")
    @patch("builtins.open", new_callable=mock_open)
    @patch("os.makedirs")
    def test_save_file_string_content(
-        self,
-        mock_makedirs: MagicMock,
-        mock_file_open: MagicMock,
-        mock_getsize: MagicMock,
-        mock_uuid: MagicMock,
-    ) -> None:
+        self, mock_makedirs, mock_file_open, mock_getsize, mock_uuid
+    ):
        # Setup
        test_uuid = "12345678-1234-5678-1234-567812345678"
        mock_uuid.return_value = uuid.UUID(test_uuid)
@@ -37,23 +48,21 @@ class TestFileService:
        mock_file_open.assert_called_once_with(expected_path, "wb")
        mock_file_open().write.assert_called_once_with(b"Hello World")

-        assert result.id == f"test_{test_uuid}.txt"
+        assert result.id == test_uuid
+        assert result.name == f"test_{test_uuid}.txt"
        assert result.type == "txt"
        assert result.size == 11
        assert result.path == expected_path
        assert result.url.endswith(expected_path.replace(os.path.sep, "/"))
+        assert result.refs is None

    @patch("uuid.uuid4")
    @patch("os.path.getsize")
    @patch("builtins.open", new_callable=mock_open)
    @patch("os.makedirs")
    def test_save_file_bytes_content(
-        self,
-        mock_makedirs: MagicMock,
-        mock_file_open: MagicMock,
-        mock_getsize: MagicMock,
-        mock_uuid: MagicMock,
-    ) -> None:
+        self, mock_makedirs, mock_file_open, mock_getsize, mock_uuid
+    ):
        # Setup
        test_uuid = "12345678-1234-5678-1234-567812345678"
        mock_uuid.return_value = uuid.UUID(test_uuid)
@@ -72,7 +81,6 @@ class TestFileService:
        mock_file_open.assert_called_once_with(expected_path, "wb")
        mock_file_open().write.assert_called_once_with(b"Hello World")
        assert result.path == expected_path
-        assert result.url.endswith(expected_path.replace(os.path.sep, "/"))
        assert result.type == "txt"

    @patch("uuid.uuid4")
@@ -80,12 +88,8 @@ class TestFileService:
    @patch("builtins.open", new_callable=mock_open)
    @patch("os.makedirs")
    def test_save_file_with_special_characters(
-        self,
-        mock_makedirs: MagicMock,
-        mock_file_open: MagicMock,
-        mock_getsize: MagicMock,
-        mock_uuid: MagicMock,
-    ) -> None:
+        self, mock_makedirs, mock_file_open, mock_getsize, mock_uuid
+    ):
        # Setup
        test_uuid = "12345678-1234-5678-1234-567812345678"
        mock_uuid.return_value = uuid.UUID(test_uuid)
@@ -103,19 +107,15 @@ class TestFileService:
        )
        mock_file_open.assert_called_once_with(expected_path, "wb")
        assert result.path == expected_path
-        assert result.url.endswith(expected_path.replace(os.path.sep, "/"))
+        assert result.name == f"test_file__{test_uuid}.txt"

    @patch("uuid.uuid4")
    @patch("os.path.getsize")
    @patch("builtins.open", new_callable=mock_open)
    @patch("os.makedirs")
    def test_save_file_default_directory(
-        self,
-        mock_makedirs: MagicMock,
-        mock_file_open: MagicMock,
-        mock_getsize: MagicMock,
-        mock_uuid: MagicMock,
-    ) -> None:
+        self, mock_makedirs, mock_file_open, mock_getsize, mock_uuid
+    ):
        # Setup
        test_uuid = "12345678-1234-5678-1234-567812345678"
        mock_uuid.return_value = uuid.UUID(test_uuid)
@@ -125,12 +125,11 @@ class TestFileService:
        result = FileService.save_file(content="Hello World", file_name="test.txt")

        # Assert
-        expected_path = os.path.join("output", "private", f"test_{test_uuid}.txt")
+        expected_path = os.path.join("output", "uploaded", f"test_{test_uuid}.txt")
        mock_makedirs.assert_called_once_with(
            os.path.dirname(expected_path), exist_ok=True
        )
        assert result.path == expected_path
-        assert result.url.endswith(expected_path.replace(os.path.sep, "/"))

    @patch("uuid.uuid4")
    @patch("os.getenv")
@@ -138,13 +137,8 @@ class TestFileService:
    @patch("builtins.open", new_callable=mock_open)
    @patch("os.makedirs")
    def test_save_file_custom_url_prefix(
-        self,
-        mock_makedirs: MagicMock,
-        mock_file_open: MagicMock,
-        mock_getsize: MagicMock,
-        mock_getenv: MagicMock,
-        mock_uuid: MagicMock,
-    ) -> None:
+        self, mock_makedirs, mock_file_open, mock_getsize, mock_getenv, mock_uuid
+    ):
        # Setup
        test_uuid = "12345678-1234-5678-1234-567812345678"
        mock_uuid.return_value = uuid.UUID(test_uuid)
@@ -163,11 +157,13 @@ class TestFileService:
        )
        mock_file_open.assert_called_once_with(expected_path, "wb")
        assert result.path == expected_path
-        assert result.url.endswith(expected_path.replace(os.path.sep, "/"))
+        # URL paths must use forward slashes, even on Windows
+        expected_url = f"/api/files/test_dir/test_{test_uuid}.txt"
+        assert result.url == expected_url

-    def test_save_file_no_extension(self) -> None:
+    def test_save_file_no_extension(self):
        # Test that saving a file without extension raises ValueError
-        with pytest.raises(ValueError, match="File name is not valid!"):
+        with pytest.raises(ValueError, match="File is not supported!"):
            FileService.save_file(
                content="Hello World", file_name="test", save_dir="test_dir"
            )
@@ -177,12 +173,8 @@ class TestFileService:
    @patch("builtins.open")
    @patch("os.makedirs")
    def test_save_file_permission_error(
-        self,
-        mock_makedirs: MagicMock,
-        mock_file_open: MagicMock,
-        mock_getsize: MagicMock,
-        mock_uuid: MagicMock,
-    ) -> None:
+        self, mock_makedirs, mock_file_open, mock_getsize, mock_uuid
+    ):
        # Setup
        test_uuid = "12345678-1234-5678-1234-567812345678"
        mock_uuid.return_value = uuid.UUID(test_uuid)
@@ -199,12 +191,8 @@ class TestFileService:
    @patch("builtins.open")
    @patch("os.makedirs")
    def test_save_file_io_error(
-        self,
-        mock_makedirs: MagicMock,
-        mock_file_open: MagicMock,
-        mock_getsize: MagicMock,
-        mock_uuid: MagicMock,
-    ) -> None:
+        self, mock_makedirs, mock_file_open, mock_getsize, mock_uuid
+    ):
        # Setup
        test_uuid = "12345678-1234-5678-1234-567812345678"
        mock_uuid.return_value = uuid.UUID(test_uuid)
--- a/Show More
+++ b/Show More