add tool call events for agent_tool utils

.changeset/mean-fireants-visit.md

@@ -0,0 +1,5 @@
+---
+"create-llama": patch
+---
+
+fix: add trycatch for generating error

.changeset/rare-eyes-protect.md

@@ -0,0 +1,5 @@
+---
+"create-llama": patch
+---
+
+bump: chat-ui and tailwind v4

.eslintrc

@@ -0,0 +1,12 @@
+{
+  "extends": [
+    "prettier"
+  ],
+  "rules": {
+    "max-params": [
+      "error",
+      4
+    ],
+    "prefer-const": "error",
+  },
+}

.github/workflows/e2e.yml

@@ -1,15 +1,12 @@
-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"
   pull_request:
     branches: [main]
-    paths-ignore:
-      - "python/llama-index-server/**"
-      - ".github/workflows/*llama_index_server.yml"
+
+env:
+  POETRY_VERSION: "1.6.1"
 
 jobs:
   e2e-python:
@@ -23,7 +20,6 @@ jobs:
         os: [macos-latest, windows-latest, ubuntu-22.04]
         frameworks: ["fastapi"]
         datasources: ["--no-files", "--example-file", "--llamacloud"]
-        template-types: ["streaming", "llamaindexserver"]
     defaults:
       run:
         shell: bash
@@ -36,10 +32,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
 
@@ -54,24 +50,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
@@ -80,17 +67,13 @@ jobs:
           LLAMA_CLOUD_API_KEY: ${{ secrets.LLAMA_CLOUD_API_KEY }}
           FRAMEWORK: ${{ matrix.frameworks }}
           DATASOURCE: ${{ matrix.datasources }}
-          TEMPLATE_TYPE: ${{ matrix.template-types }}
-          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.datasources }}-${{ matrix.template-types }}
-          path: packages/create-llama/playwright-report/
+          name: playwright-report-python-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.datasources }}
+          path: ./playwright-report/
           overwrite: true
           retention-days: 30
 
@@ -100,12 +83,11 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        node-version: [20, 22]
+        node-version: [18, 20]
         python-version: ["3.11"]
         os: [macos-latest, windows-latest, ubuntu-22.04]
-        frameworks: ["nextjs"]
+        frameworks: ["nextjs", "express"]
         datasources: ["--no-files", "--example-file", "--llamacloud"]
-        template-types: ["streaming", "llamaindexserver"]
     defaults:
       run:
         shell: bash
@@ -118,10 +100,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
 
@@ -136,30 +118,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 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:typescript
@@ -168,14 +135,12 @@ jobs:
           LLAMA_CLOUD_API_KEY: ${{ secrets.LLAMA_CLOUD_API_KEY }}
           FRAMEWORK: ${{ matrix.frameworks }}
           DATASOURCE: ${{ matrix.datasources }}
-          TEMPLATE_TYPE: ${{ matrix.template-types }}
-          SERVER_PACKAGE_PATH: ${{ runner.temp }}/llamaindex-server.tgz
-        working-directory: packages/create-llama
+        working-directory: .
 
       - uses: actions/upload-artifact@v4
         if: always()
         with:
-          name: playwright-report-typescript-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.datasources }}-node${{ matrix.node-version }}-${{ matrix.template-types }}
-          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

.github/workflows/lint_on_push_or_pull.yml

@@ -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"

.github/workflows/release.yml

@@ -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 }}

.github/workflows/release_llama_index_server.yml

@@ -0,0 +1,122 @@
+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'
+
+    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: Build package
+        run: poetry build
+
+      - name: Publish to PyPI
+        env:
+          POETRY_PYPI_TOKEN_PYPI: ${{ secrets.LLAMA_INDEX_PYPI_TOKEN }}
+        run: poetry publish --build
+
+      - 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 }}

.github/workflows/test_llama_index_server.yml

@@ -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/

.gitignore

@@ -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

.husky/pre-commit

@@ -1,4 +1,3 @@
 pnpm format
 pnpm lint
-uvx ruff check .
-uvx ruff format . --check 
+uvx ruff format --check templates/

.prettierignore

@@ -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/

CHANGELOG.md

@@ -1,146 +1,5 @@
 # create-llama
 
-## 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
-
-- 5988657: chore: bump llmaindex
-
-## 0.5.6
-
-### Patch Changes
-
-- d363ced: Bump llamaindex server packages
-
-## 0.5.5
-
-### Patch Changes
-
-- ee85320: The default custom deep research component does not work.
-
-## 0.5.4
-
-### Patch Changes
-
-- 7c3b279: Support code generation of event components using an LLM (Python)
-
-## 0.5.3
-
-### Patch Changes
-
-- 76ec360: Update templates to use new chat ui config
-
-## 0.5.2
-
-### Patch Changes
-
-- c9f8f8d: Use custom component for deep research use case
-
-## 0.5.1
-
-### Patch Changes
-
-- 08b3e07: Simplify the local index code.
-
-## 0.5.0
-
-### Minor Changes
-
-- 54c9e2f: Simplified generated code using LlamaIndexServer
-
-### Patch Changes
-
-- 0e4ecfa: fix: add trycatch for generating error
-- ee69ce7: bump: chat-ui and tailwind v4
-
 ## 0.4.0
 
 ### Minor Changes

CLAUDE.md

@@ -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

README.md

@@ -55,7 +55,7 @@ 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
@@ -106,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)

create-app.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-extraneous-dependencies */
 import path from "path";
 import { green, yellow } from "picocolors";
 import { tryGitInit } from "./helpers/git";
@@ -89,7 +90,7 @@ export async function createApp({
   // Install backend
   await installTemplate({ ...args, backend: true });
 
-  if (frontend && framework === "fastapi" && template !== "llamaindexserver") {
+  if (frontend && framework === "fastapi") {
     // install frontend
     const frontendRoot = path.join(root, ".frontend");
     await makeDir(frontendRoot);
@@ -109,7 +110,7 @@ export async function createApp({
     console.log();
   }
 
-  if (toolsRequireConfig(tools) && template !== "llamaindexserver") {
+  if (toolsRequireConfig(tools)) {
     const configFile =
       framework === "fastapi" ? "config/tools.yaml" : "config/tools.json";
     console.log(

e2e/python/resolve_dependencies.spec.ts

@@ -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 };
+}

e2e/shared/multiagent_template.spec.ts

@@ -1,5 +1,6 @@
+/* eslint-disable turbo/no-undeclared-env-vars */
 import { expect, test } from "@playwright/test";
-import { ChildProcess, execSync } from "child_process";
+import { ChildProcess } from "child_process";
 import fs from "fs";
 import path from "path";
 import type {
@@ -12,31 +13,19 @@ 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 as string)
-  : "--example-file";
-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 appType: AppType = templateFramework === "fastapi" ? "--frontend" : "";
 const userMessage = "Write a blog post about physical standards for letters";
-const templateUseCases = [
-  "agentic_rag",
-  "financial_report",
-  "deep_research",
-  "code_generator",
-];
-const ejectDir = "next";
+const templateUseCases = ["financial_report", "blog", "form_filling"];
 
 for (const useCase of templateUseCases) {
-  test.describe(`Test use case ${useCase} ${templateFramework} ${dataSource} ${templateUI} ${appType} ${templatePostInstallAction}`, async () => {
+  test.describe(`Test multiagent template ${useCase} ${templateFramework} ${dataSource} ${templateUI} ${appType} ${templatePostInstallAction}`, async () => {
     test.skip(
-      dataSource === "--no-files" || templateFramework === "express",
-      "The llamaindexserver template currently only works with nextjs, fastapi. We also only run on Linux to speed up tests.",
+      process.platform !== "linux" || process.env.DATASOURCE === "--no-files",
+      "The multiagent template currently only works with files. We also only run on Linux to speed up tests.",
     );
-    const useLlamaParse = dataSource === "--llamacloud";
     let port: number;
     let cwd: string;
     let name: string;
@@ -49,7 +38,7 @@ for (const useCase of templateUseCases) {
       cwd = await createTestDir();
       const result = await runCreateLlama({
         cwd,
-        templateType: "llamaindexserver",
+        templateType: "multiagent",
         templateFramework,
         dataSource,
         vectorDb,
@@ -58,9 +47,6 @@ for (const useCase of templateUseCases) {
         templateUI,
         appType,
         useCase,
-        llamaCloudProjectName,
-        llamaCloudIndexName,
-        useLlamaParse,
       });
       name = result.projectName;
       appProcess = result.appProcess;
@@ -77,9 +63,7 @@ for (const useCase of templateUseCases) {
           templateFramework === "express",
       );
       await page.goto(`http://localhost:${port}`);
-      await expect(page.getByText("Built by LlamaIndex")).toBeVisible({
-        timeout: 5 * 60 * 1000,
-      });
+      await expect(page.getByText("Built by LlamaIndex")).toBeVisible();
     });
 
     test("Frontend should be able to submit a message and receive the start of a streamed response", async ({
@@ -88,9 +72,9 @@ for (const useCase of templateUseCases) {
       test.skip(
         templatePostInstallAction !== "runApp" ||
           useCase === "financial_report" ||
-          useCase === "deep_research" ||
+          useCase === "form_filling" ||
           templateFramework === "express",
-        "Skip chat tests for financial report and deep research.",
+        "Skip chat tests for financial report and form filling.",
       );
       await page.goto(`http://localhost:${port}`);
       await page.fill("form textarea", userMessage);
@@ -102,37 +86,9 @@ for (const useCase of templateUseCases) {
       await page.click("form button[type=submit]");
 
       const response = await responsePromise;
-      console.log(`Response status: ${response.status()}`);
-      const responseBody = await response
-        .text()
-        .catch((e) => `Error reading body: ${e}`);
-      console.log(`Response body: ${responseBody}`);
-
       expect(response.ok()).toBeTruthy();
     });
 
-    test("Should successfully eject, install dependencies and build without errors", async () => {
-      test.skip(
-        templateFramework !== "nextjs" ||
-          useCase !== "code_generator" ||
-          dataSource === "--llamacloud",
-        "Eject test only applies to Next.js framework, code generator use case, and non-llamacloud",
-      );
-
-      // Run eject command
-      execSync("npm run eject", { cwd: path.join(cwd, name) });
-
-      // Verify next directory exists
-      const nextDirExists = fs.existsSync(path.join(cwd, name, ejectDir));
-      expect(nextDirExists).toBeTruthy();
-
-      // Install dependencies in next directory
-      execSync("npm install", { cwd: path.join(cwd, name, ejectDir) });
-
-      // Run build
-      execSync("npm run build", { cwd: path.join(cwd, name, ejectDir) });
-    });
-
     // clean processes
     test.afterAll(async () => {
       appProcess?.kill();

e2e/shared/reflex_template.spec.ts

@@ -1,3 +1,4 @@
+/* eslint-disable turbo/no-undeclared-env-vars */
 import { expect, test } from "@playwright/test";
 import { ChildProcess } from "child_process";
 import fs from "fs";

e2e/shared/streaming_template.spec.ts

@@ -1,3 +1,4 @@
+/* eslint-disable turbo/no-undeclared-env-vars */
 import { expect, test } from "@playwright/test";
 import { ChildProcess } from "child_process";
 import fs from "fs";

e2e/typescript/resolve_dependencies.spec.ts

@@ -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;
+    }
+  }
+});

e2e/utils.ts

@@ -67,8 +67,8 @@ export async function runCreateLlama({
   ].join("-");
 
   // Handle different data source types
-  const dataSourceArgs = [];
-  if (dataSource.includes("--web-source")) {
+  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")) {
@@ -113,12 +113,7 @@ export async function runCreateLlama({
   if (observability) {
     commandArgs.push("--observability", observability);
   }
-  if (
-    (templateType === "multiagent" ||
-      templateType === "reflex" ||
-      templateType === "llamaindexserver") &&
-    useCase
-  ) {
+  if ((templateType === "multiagent" || templateType === "reflex") && useCase) {
     commandArgs.push("--use-case", useCase);
   }
 

eslint.config.mjs

@@ -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/**",
-    ],
-  },
-);

helpers/copy.ts

@@ -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";

helpers/env-variables.ts

@@ -44,7 +44,6 @@ const renderEnvVar = (envVars: EnvVar[]): string => {
 const getVectorDBEnvs = (
   vectorDb?: TemplateVectorDB,
   framework?: TemplateFramework,
-  template?: TemplateType,
 ): EnvVar[] => {
   if (!vectorDb || !framework) {
     return [];
@@ -169,7 +168,7 @@ const getVectorDBEnvs = (
           description:
             "The organization ID for the LlamaCloud project (uses default organization if not specified)",
         },
-        ...(framework === "nextjs" && template !== "llamaindexserver"
+        ...(framework === "nextjs"
           ? // activate index selector per default (not needed for non-NextJS backends as it's handled by createFrontendEnvFile)
             [
               {
@@ -181,7 +180,7 @@ const getVectorDBEnvs = (
             ]
           : []),
       ];
-    case "chroma": {
+    case "chroma":
       const envs = [
         {
           name: "CHROMA_COLLECTION",
@@ -206,7 +205,6 @@ Otherwise, use CHROMA_HOST and CHROMA_PORT config above`,
         });
       }
       return envs;
-    }
     case "weaviate":
       return [
         {
@@ -225,15 +223,13 @@ Otherwise, use CHROMA_HOST and CHROMA_PORT config above`,
         },
       ];
     default:
-      return template !== "llamaindexserver"
-        ? [
-            {
-              name: "STORAGE_CACHE_DIR",
-              description: "The directory to store the local storage cache.",
-              value: ".cache",
-            },
-          ]
-        : [];
+      return [
+        {
+          name: "STORAGE_CACHE_DIR",
+          description: "The directory to store the local storage cache.",
+          value: ".cache",
+        },
+      ];
   }
 };
 
@@ -386,42 +382,38 @@ const getModelEnvs = (modelConfig: ModelConfig): EnvVar[] => {
 
 const getFrameworkEnvs = (
   framework: TemplateFramework,
-  template: TemplateType,
   port?: number,
 ): EnvVar[] => {
   const sPort = port?.toString() || "8000";
-  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`,
-          },
-        ]
-      : [];
+  const result: EnvVar[] = [
+    {
+      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(
       ...[
         {
           name: "APP_HOST",
-          description: "The address to start the FastAPI app.",
+          description: "The address to start the backend app.",
           value: "0.0.0.0",
         },
         {
           name: "APP_PORT",
-          description: "The port to start the FastAPI app.",
+          description: "The port to start the backend app.",
           value: sPort,
         },
       ],
     );
   }
-  if (framework === "nextjs" && template !== "llamaindexserver") {
+  if (framework === "nextjs") {
     result.push({
       name: "NEXT_PUBLIC_CHAT_API",
       description:
@@ -577,41 +569,25 @@ export const createBackendEnvFile = async (
     | "port"
     | "tools"
     | "observability"
-    | "useLlamaParse"
   >,
 ) => {
   // Init env values
   const envFileName = ".env";
   const envVars: EnvVar[] = [
-    ...(opts.useLlamaParse
-      ? [
-          {
-            name: "LLAMA_CLOUD_API_KEY",
-            description: `The Llama Cloud API key.`,
-            value: opts.llamaCloudKey,
-          },
-        ]
-      : []),
-    ...getVectorDBEnvs(opts.vectorDb, opts.framework, opts.template),
-    ...getToolEnvs(opts.tools),
-    ...getFrameworkEnvs(opts.framework, opts.template, opts.port),
+    {
+      name: "LLAMA_CLOUD_API_KEY",
+      description: `The Llama Cloud API key.`,
+      value: opts.llamaCloudKey,
+    },
     // 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),
-        ]),
+    ...getModelEnvs(opts.modelConfig),
+    ...getEngineEnvs(),
+    ...getVectorDBEnvs(opts.vectorDb, opts.framework),
+    ...getFrameworkEnvs(opts.framework, opts.port),
+    ...getToolEnvs(opts.tools),
+    ...getTemplateEnvs(opts.template),
+    ...getObservabilityEnvs(opts.observability),
+    ...getSystemPromptEnv(opts.tools, opts.dataSources, opts.template),
   ];
   // Render and write env file
   const content = renderEnvVar(envVars);

helpers/git.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-extraneous-dependencies */
 import { execSync } from "child_process";
 import fs from "fs";
 import path from "path";

helpers/index.ts

@@ -1,7 +1,7 @@
 import { callPackageManager } from "./install";
 
 import path from "path";
-import picocolors, { cyan } from "picocolors";
+import { cyan } from "picocolors";
 
 import fsExtra from "fs-extra";
 import { writeLoadersConfig } from "./datasources";
@@ -9,6 +9,7 @@ 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";
@@ -18,11 +19,9 @@ import {
   ModelConfig,
   TemplateDataSource,
   TemplateFramework,
-  TemplateUseCase,
   TemplateVectorDB,
 } from "./types";
 import { installTSTemplate } from "./typescript";
-import { isHavingUvLockFile, tryUvRun } from "./uv";
 
 const checkForGenerateScript = (
   modelConfig: ModelConfig,
@@ -42,11 +41,7 @@ const checkForGenerateScript = (
     missingSettings.push("your LLAMA_CLOUD_API_KEY");
   }
 
-  if (
-    vectorDb !== undefined &&
-    vectorDb !== "none" &&
-    vectorDb !== "llamacloud"
-  ) {
+  if (vectorDb !== "none" && vectorDb !== "llamacloud") {
     missingSettings.push("your Vector DB environment variables");
   }
 
@@ -61,12 +56,11 @@ async function generateContextData(
   vectorDb?: TemplateVectorDB,
   llamaCloudKey?: string,
   useLlamaParse?: boolean,
-  useCase?: TemplateUseCase,
 ) {
   if (packageManager) {
     const runGenerate = `${cyan(
       framework === "fastapi"
-        ? "uv run generate"
+        ? "poetry run generate"
         : `${packageManager} run generate`,
     )}`;
 
@@ -80,43 +74,32 @@ 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 =
-          useCase !== "code_generator" && useCase !== "document_generator"; // Artifact use case doesn't use index.
-
-        if (shouldRunGenerate) {
-          await callPackageManager(packageManager, true, ["run", "generate"]);
-        }
+        await callPackageManager(packageManager, true, ["run", "generate"]);
         return;
       }
     }
 
     const settingsMessage = `After setting ${missingSettings.join(" and ")}, run ${runGenerate} to generate the context data.`;
-    console.log(picocolors.yellow(`\n${settingsMessage}\n\n`));
+    console.log(`\n${settingsMessage}\n\n`);
   }
 }
 
 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 (
@@ -183,17 +166,6 @@ export const installTemplate = async (
 
   if (props.framework === "fastapi") {
     await installPythonTemplate(props);
-  } else {
-    await installTSTemplate(props);
-  }
-
-  // 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
@@ -203,13 +175,26 @@ export const installTemplate = async (
         props.useLlamaParse,
       );
     }
+  } else {
+    await installTSTemplate(props);
   }
 
+  // write tools configuration
+  await writeToolsConfig(
+    props.root,
+    props.tools,
+    props.framework === "fastapi" ? ConfigFileType.YAML : ConfigFileType.JSON,
+  );
+
   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") {
+    if (
+      props.template === "streaming" ||
+      props.template === "multiagent" ||
+      props.template === "reflex"
+    ) {
       await createBackendEnvFile(props.root, props);
     }
 
@@ -231,7 +216,6 @@ export const installTemplate = async (
         props.vectorDb,
         props.llamaCloudKey,
         props.useLlamaParse,
-        props.useCase,
       );
     }
 

helpers/install.ts

@@ -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";

helpers/is-folder-empty.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-extraneous-dependencies */
 import fs from "fs";
 import path from "path";
 import { blue, green } from "picocolors";

helpers/llama-pack.ts

@@ -143,6 +143,6 @@ export const installLlamapackProject = async ({
   await copyData({ root });
   await installLlamapackExample({ root, llamapack });
   if (postInstallAction === "runApp" || postInstallAction === "dependencies") {
-    installPythonDependencies();
+    installPythonDependencies({ noRoot: true });
   }
 };

helpers/poetry.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-extraneous-dependencies */
 import { execSync } from "child_process";
 import fs from "fs";
 

helpers/providers/index.ts

@@ -28,7 +28,7 @@ export async function askModelConfig({
 }: ModelConfigQuestionsParams): Promise<ModelConfig> {
   let modelProvider: ModelProvider = DEFAULT_MODEL_PROVIDER;
   if (askModels) {
-    const choices = [
+    let choices = [
       { title: "OpenAI", value: "openai" },
       { title: "Groq", value: "groq" },
       { title: "Ollama", value: "ollama" },

helpers/python.ts

@@ -3,17 +3,15 @@ import path from "path";
 import { cyan, red } from "picocolors";
 import { parse, stringify } from "smol-toml";
 import terminalLink from "terminal-link";
-import { isUvAvailable, tryUvSync } from "./uv";
 
-import { isCI } from "ci-info";
 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";
@@ -31,8 +29,6 @@ const getAdditionalDependencies = (
   dataSources?: TemplateDataSource[],
   tools?: Tool[],
   templateType?: TemplateType,
-  observability?: TemplateObservability,
-  // eslint-disable-next-line max-params
 ) => {
   const dependencies: Dependency[] = [];
 
@@ -41,21 +37,21 @@ const getAdditionalDependencies = (
     case "mongo": {
       dependencies.push({
         name: "llama-index-vector-stores-mongodb",
-        version: ">=0.3.2,<0.4.0",
+        version: "^0.6.0",
       });
       break;
     }
     case "pg": {
       dependencies.push({
         name: "llama-index-vector-stores-postgres",
-        version: ">=0.3.2,<0.4.0",
+        version: "^0.3.2",
       });
       break;
     }
     case "pinecone": {
       dependencies.push({
         name: "llama-index-vector-stores-pinecone",
-        version: ">=0.4.1,<0.5.0",
+        version: "^0.4.1",
         constraints: {
           python: ">=3.11,<3.13",
         },
@@ -65,25 +61,25 @@ const getAdditionalDependencies = (
     case "milvus": {
       dependencies.push({
         name: "llama-index-vector-stores-milvus",
-        version: ">=0.3.0,<0.4.0",
+        version: "^0.3.0",
       });
       dependencies.push({
         name: "pymilvus",
-        version: ">=2.4.4,<3.0.0",
+        version: "2.4.4",
       });
       break;
     }
     case "astra": {
       dependencies.push({
         name: "llama-index-vector-stores-astra-db",
-        version: ">=0.4.0,<0.5.0",
+        version: "^0.4.0",
       });
       break;
     }
     case "qdrant": {
       dependencies.push({
         name: "llama-index-vector-stores-qdrant",
-        version: ">=0.4.0,<0.5.0",
+        version: "^0.4.0",
         constraints: {
           python: ">=3.11,<3.13",
         },
@@ -93,25 +89,21 @@ const getAdditionalDependencies = (
     case "chroma": {
       dependencies.push({
         name: "llama-index-vector-stores-chroma",
-        version: ">=0.4.0,<0.5.0",
-      });
-      dependencies.push({
-        name: "onnxruntime",
-        version: "<1.22.0",
+        version: "^0.4.0",
       });
       break;
     }
     case "weaviate": {
       dependencies.push({
         name: "llama-index-vector-stores-weaviate",
-        version: ">=1.2.3,<2.0.0",
+        version: "^1.2.3",
       });
       break;
     }
     case "llamacloud":
       dependencies.push({
         name: "llama-index-indices-managed-llama-cloud",
-        version: ">=0.6.3,<0.7.0",
+        version: "^0.6.3",
       });
       break;
   }
@@ -124,28 +116,28 @@ const getAdditionalDependencies = (
         case "file":
           dependencies.push({
             name: "docx2txt",
-            version: ">=0.8,<0.9",
+            version: "^0.8",
           });
           break;
         case "web":
           dependencies.push({
             name: "llama-index-readers-web",
-            version: ">=0.3.0,<0.4.0",
+            version: "^0.3.0",
           });
           break;
         case "db":
           dependencies.push({
             name: "llama-index-readers-database",
-            version: ">=0.3.0,<0.4.0",
+            version: "^0.3.0",
           });
           dependencies.push({
             name: "pymysql",
-            version: ">=1.1.0,<2.0.0",
+            version: "^1.1.0",
             extras: ["rsa"],
           });
           dependencies.push({
             name: "psycopg2-binary",
-            version: ">=2.9.9,<3.0.0",
+            version: "^2.9.9",
           });
           break;
       }
@@ -164,137 +156,157 @@ const getAdditionalDependencies = (
     case "ollama":
       dependencies.push({
         name: "llama-index-llms-ollama",
-        version: ">=0.5.0,<0.6.0",
+        version: "0.3.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-ollama",
-        version: ">=0.6.0,<0.7.0",
+        version: "0.3.0",
       });
       break;
     case "openai":
       if (templateType !== "multiagent") {
         dependencies.push({
           name: "llama-index-llms-openai",
-          version: ">=0.3.2,<0.4.0",
+          version: "^0.3.2",
         });
         dependencies.push({
           name: "llama-index-embeddings-openai",
-          version: ">=0.3.1,<0.4.0",
+          version: "^0.3.1",
         });
         dependencies.push({
           name: "llama-index-agent-openai",
-          version: ">=0.4.0,<0.5.0",
+          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.3.0,<0.4.0",
+        version: "0.2.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-fastembed",
-        version: ">=0.3.0,<0.4.0",
+        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.6.0,<0.7.0",
+        version: "0.3.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-fastembed",
-        version: ">=0.3.0,<0.4.0",
+        version: "^0.2.0",
       });
       break;
     case "gemini":
       dependencies.push({
         name: "llama-index-llms-gemini",
-        version: ">=0.4.0,<0.5.0",
+        version: "0.3.4",
       });
       dependencies.push({
         name: "llama-index-embeddings-gemini",
-        version: ">=0.3.0,<0.4.0",
+        version: "^0.2.0",
       });
       break;
     case "mistral":
       dependencies.push({
         name: "llama-index-llms-mistralai",
-        version: ">=0.4.0,<0.5.0",
+        version: "0.2.1",
       });
       dependencies.push({
         name: "llama-index-embeddings-mistralai",
-        version: ">=0.3.0,<0.4.0",
+        version: "0.2.0",
       });
       break;
     case "azure-openai":
       dependencies.push({
         name: "llama-index-llms-azure-openai",
-        version: ">=0.3.0,<0.4.0",
+        version: "0.2.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-azure-openai",
-        version: ">=0.3.0,<0.4.0",
+        version: "0.2.4",
       });
       break;
     case "huggingface":
       dependencies.push({
         name: "llama-index-llms-huggingface",
-        version: ">=0.5.0,<0.6.0",
+        version: "^0.3.5",
       });
       dependencies.push({
         name: "llama-index-embeddings-huggingface",
-        version: ">=0.5.0,<0.6.0",
+        version: "^0.3.1",
       });
       dependencies.push({
         name: "optimum",
-        version: ">=1.23.3,<2.0.0",
+        version: "^1.23.3",
         extras: ["onnxruntime"],
       });
       break;
     case "t-systems":
       dependencies.push({
         name: "llama-index-agent-openai",
-        version: ">=0.4.0,<0.5.0",
+        version: "0.3.0",
       });
       dependencies.push({
         name: "llama-index-llms-openai-like",
-        version: ">=0.3.0,<0.4.0",
+        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,<0.4.0",
-      });
-    }
-  }
-
-  // If app template is llama-index-server and CI and SERVER_PACKAGE_PATH is set,
-  // add @llamaindex/server to dependencies
-  if (
-    templateType === "llamaindexserver" &&
-    isCI &&
-    process.env.SERVER_PACKAGE_PATH
-  ) {
-    dependencies.push({
-      name: "llama-index-server",
-      version: `@file://${process.env.SERVER_PACKAGE_PATH}`,
-    });
-  }
-
   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")) {
@@ -317,100 +329,19 @@ export const addDependencies = async (
     // Parse toml file
     const file = path.join(projectDir, FILENAME);
     const fileContent = await fs.readFile(file, "utf8");
-    let fileParsed: any;
-    try {
-      fileParsed = parse(fileContent);
-    } catch (parseError) {
-      console.error(`Error parsing ${FILENAME}:`, parseError);
-      throw new Error(
-        `Failed to parse ${FILENAME}. Please ensure it's valid TOML.`,
-      );
-    }
+    const fileParsed = parse(fileContent);
 
-    // Ensure [project] and [project.dependencies] exist
-    if (!fileParsed.project) {
-      fileParsed.project = {};
-    }
-    if (
-      !fileParsed.project.dependencies ||
-      !Array.isArray(fileParsed.project.dependencies)
-    ) {
-      // If dependencies exist but aren't an array, log a warning or error.
-      // For now, we'll overwrite it, assuming the intent is to use the standard array format.
-      console.warn(
-        `[project.dependencies] in ${FILENAME} is not an array. It will be overwritten.`,
-      );
-      fileParsed.project.dependencies = [];
-    }
-
-    const existingDependencies: string[] = fileParsed.project.dependencies;
-    const addedDeps: string[] = [];
-    const updatedDeps: string[] = [];
-
-    // Add or update dependencies
-    for (const newDep of dependencies) {
-      let depString = newDep.name;
-      if (newDep.extras && newDep.extras.length > 0) {
-        depString += `[${newDep.extras.join(",")}]`;
-      }
-      if (newDep.version) {
-        depString += newDep.version;
-      }
-
-      let found = false;
-      for (let i = 0; i < existingDependencies.length; i++) {
-        const existingDepNameMatch =
-          existingDependencies[i].match(/^([a-zA-Z0-9._-]+)/);
-        if (
-          existingDepNameMatch &&
-          existingDepNameMatch[1].toLowerCase() === depString.toLowerCase()
-        ) {
-          // Found existing dependency, update it
-          if (existingDependencies[i] !== depString) {
-            updatedDeps.push(`${existingDependencies[i]} -> ${depString}`);
-            existingDependencies[i] = depString;
-          }
-          found = true;
-          break;
-        }
-      }
-
-      if (!found) {
-        // Add new dependency
-        existingDependencies.push(depString);
-        addedDeps.push(depString);
-      }
-      // Handle python version constraints separately (if any)
-      if (newDep.constraints?.python) {
-        if (
-          !fileParsed.project["requires-python"] ||
-          fileParsed.project["requires-python"] !== newDep.constraints.python
-        ) {
-          // This simple overwrite might not be ideal; merging constraints is complex.
-          // For now, let's just set it if the new dependency has one.
-          console.log(
-            `Setting requires-python = "${newDep.constraints.python}" from dependency ${newDep.name}`,
-          );
-          fileParsed.project["requires-python"] = newDep.constraints.python;
-        }
-      }
-    }
+    // 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);
 
-    if (addedDeps.length > 0) {
-      console.log(`\nAdded dependencies to ${cyan(FILENAME)}:`);
-      addedDeps.forEach((dep) => console.log(`  ${dep}`));
-    }
-    if (updatedDeps.length > 0) {
-      console.log(`\nUpdated dependencies in ${cyan(FILENAME)}:`);
-      updatedDeps.forEach((dep) => console.log(`  ${dep}`));
-    }
-    if (addedDeps.length > 0 || updatedDeps.length > 0) {
-      console.log(""); // Newline for spacing
-    }
+    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`,
@@ -419,16 +350,18 @@ export const addDependencies = async (
   }
 };
 
-export const installPythonDependencies = () => {
-  if (isUvAvailable()) {
+export const installPythonDependencies = (
+  { noRoot }: { noRoot: boolean } = { noRoot: false },
+) => {
+  if (isPoetryAvailable()) {
     console.log(
-      `Installing Python dependencies using uv. This may take a while...`,
+      `Installing python dependencies using poetry. This may take a while...`,
     );
-    const installSuccessful = tryUvSync();
+    const installSuccessful = tryPoetryInstall(noRoot);
     if (!installSuccessful) {
       console.error(
         red(
-          "Installing dependencies using uv failed. Please check the error log above and ensure uv is installed correctly.",
+          "Installing dependencies using poetry failed. Please check error log above and try running create-llama again.",
         ),
       );
       process.exit(1);
@@ -436,34 +369,57 @@ export const installPythonDependencies = () => {
   } else {
     console.error(
       red(
-        `uv is not available in the current environment. Please check ${terminalLink(
-          "uv Installation",
-          `https://github.com/astral-sh/uv#installation`,
-        )} to install uv first, then run create-llama again.`,
+        `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 ({
+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", "streaming", framework);
+  }
+  await copy("**", root, {
+    parents: true,
+    cwd: templatePath,
+    rename: assetRelocator,
+  });
+
   const compPath = path.join(templatesDir, "components");
   const enginePath = path.join(root, "app", "engine");
 
@@ -553,7 +509,34 @@ const installLegacyPythonTemplate = async ({
     }
   }
 
+  console.log("Adding additional dependencies");
+
+  const addOnDependencies = getAdditionalDependencies(
+    modelConfig,
+    vectorDb,
+    dataSources,
+    tools,
+    template,
+  );
+
   if (observability && observability !== "none") {
+    if (observability === "traceloop") {
+      addOnDependencies.push({
+        name: "traceloop-sdk",
+        version: "^0.15.11",
+      });
+    }
+
+    if (observability === "llamatrace") {
+      addOnDependencies.push({
+        name: "llama-index-callbacks-arize-phoenix",
+        version: "^0.3.0",
+        constraints: {
+          python: ">=3.11,<3.13",
+        },
+      });
+    }
+
     const templateObservabilityPath = path.join(
       templatesDir,
       "components",
@@ -565,140 +548,6 @@ const installLegacyPythonTemplate = async ({
       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("*.py", path.join(root, "app"), {
-    parents: true,
-    cwd: path.join(templatesDir, "components", "use-cases", "python", useCase),
-  });
-
-  // Copy custom UI component code
-  await copy(`*`, path.join(root, "components"), {
-    parents: true,
-    cwd: path.join(templatesDir, "components", "ui", "use-cases", useCase),
-  });
-
-  // Copy layout components to layout folder in root
-  await copy("*", path.join(root, "layout"), {
-    parents: true,
-    cwd: path.join(templatesDir, "components", "ui", "layout"),
-  });
-
-  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", "use-cases", "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,
-    observability,
-  );
 
   await addDependencies(root, addOnDependencies);
 

helpers/run-app.ts

@@ -34,24 +34,14 @@ export function runReflexApp(appPath: string, port: number) {
     "--frontend-port",
     port.toString(),
   ];
-  return createProcess("uv", commandArgs, {
+  return createProcess("poetry", commandArgs, {
     stdio: "inherit",
     cwd: appPath,
   });
 }
 
-export function runFastAPIApp(
-  appPath: string,
-  port: number,
-  template: TemplateType,
-) {
-  let commandArgs: string[];
-  if (template === "streaming") {
-    commandArgs = ["run", "dev"];
-  } else {
-    commandArgs = ["run", "fastapi", "dev", "--port", `${port}`];
-  }
-  return createProcess("uv", commandArgs, {
+export function runFastAPIApp(appPath: string, port: number) {
+  return createProcess("poetry", ["run", "dev"], {
     stdio: "inherit",
     cwd: appPath,
     env: { ...process.env, APP_PORT: `${port}` },
@@ -83,7 +73,7 @@ export async function runApp(
         : framework === "fastapi"
           ? runFastAPIApp
           : runTSApp;
-    await appRunner(appPath, port || defaultPort, template);
+    await appRunner(appPath, port || defaultPort);
   } catch (error) {
     console.error("Failed to run app:", error);
     throw error;

helpers/tools.ts

@@ -41,7 +41,7 @@ export const supportedTools: Tool[] = [
     dependencies: [
       {
         name: "llama-index-tools-google",
-        version: ">=0.3.0,<0.4.0",
+        version: "^0.3.0",
       },
     ],
     supportedFrameworks: ["fastapi"],
@@ -62,7 +62,7 @@ export const supportedTools: Tool[] = [
     dependencies: [
       {
         name: "duckduckgo-search",
-        version: ">=6.3.5,<7.0.0",
+        version: "^6.3.5",
       },
     ],
     supportedFrameworks: ["fastapi"], // TODO: Re-enable this tool once the duck-duck-scrape TypeScript library works again
@@ -82,7 +82,7 @@ For better results, you can specify the region parameter to get results from a s
     dependencies: [
       {
         name: "llama-index-tools-wikipedia",
-        version: ">=0.3.0,<0.4.0",
+        version: "^0.3.0",
       },
     ],
     supportedFrameworks: ["fastapi", "express", "nextjs"],
@@ -102,11 +102,11 @@ For better results, you can specify the region parameter to get results from a s
     dependencies: [
       {
         name: "xhtml2pdf",
-        version: ">=0.2.14,<0.3.0",
+        version: "^0.2.14",
       },
       {
         name: "markdown",
-        version: ">=3.7.0,<4.0.0",
+        version: "^3.7",
       },
     ],
     type: ToolType.LOCAL,
@@ -124,7 +124,7 @@ For better results, you can specify the region parameter to get results from a s
     dependencies: [
       {
         name: "e2b_code_interpreter",
-        version: ">=1.1.1,<1.2.0",
+        version: "1.0.3",
       },
     ],
     supportedFrameworks: ["fastapi", "express", "nextjs"],
@@ -155,7 +155,7 @@ For better results, you can specify the region parameter to get results from a s
     dependencies: [
       {
         name: "e2b_code_interpreter",
-        version: ">=1.1.1,<1.2.0",
+        version: "1.0.3",
       },
     ],
     supportedFrameworks: ["fastapi", "express", "nextjs"],
@@ -184,7 +184,7 @@ For better results, you can specify the region parameter to get results from a s
       },
       {
         name: "jsonschema",
-        version: ">=4.22.0,<5.0.0",
+        version: "^4.22.0",
       },
       {
         name: "llama-index-tools-requests",
@@ -247,11 +247,11 @@ For better results, you can specify the region parameter to get results from a s
     dependencies: [
       {
         name: "pandas",
-        version: ">=2.2.3,<3.0.0",
+        version: "^2.2.3",
       },
       {
         name: "tabulate",
-        version: ">=0.9.0,<1.0.0",
+        version: "^0.9.0",
       },
     ],
   },

helpers/types.ts

@@ -24,8 +24,7 @@ export type TemplateType =
   | "community"
   | "llamapack"
   | "multiagent"
-  | "reflex"
-  | "llamaindexserver";
+  | "reflex";
 export type TemplateFramework = "nextjs" | "express" | "fastapi";
 export type TemplateUI = "html" | "shadcn";
 export type TemplateVectorDB =
@@ -56,10 +55,7 @@ export type TemplateUseCase =
   | "deep_research"
   | "form_filling"
   | "extractor"
-  | "contract_review"
-  | "agentic_rag"
-  | "code_generator"
-  | "document_generator";
+  | "contract_review";
 // Config for both file and folder
 export type FileSourceConfig =
   | {

helpers/typescript.ts

@@ -8,107 +8,42 @@ 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("**", path.join(root), {
-    cwd: path.join(
-      templatesDir,
-      "components",
-      "use-cases",
-      "typescript",
-      useCase,
-    ),
-    rename: assetRelocator,
-  });
-
-  // copy workflow UI components to components folder in root
-  await copy("*", path.join(root, "components"), {
-    parents: true,
-    cwd: path.join(templatesDir, "components", "ui", "use-cases", useCase),
-  });
-
-  // copy layout components to layout folder in root
-  await copy("*", path.join(root, "layout"), {
-    parents: true,
-    cwd: path.join(templatesDir, "components", "ui", "layout"),
-  });
-
-  // Override generate.ts if workflow use case doesn't use custom UI
-  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",
-    });
-  }
-
-  // Simplify use case code
-  if (useCase === "code_generator" || useCase === "document_generator") {
-    // Artifact use case doesn't use index.
-    // We don't need data.ts, generate.ts
-    await fs.rm(path.join(root, "src", "app", "data.ts"));
-    // TODO: Remove generate index in generate.ts and package.json if possible
-  }
-};
-
-const installLegacyTSTemplate = async ({
+/**
+ * Install a LlamaIndex internal template to a given `root` directory.
+ */
+export const installTSTemplate = async ({
+  appName,
   root,
+  packageManager,
+  isOnline,
   template,
-  backend,
   framework,
   ui,
   vectorDb,
+  postInstallAction,
+  backend,
   observability,
   tools,
   dataSources,
   useLlamaParse,
   useCase,
   modelConfig,
-  relativeEngineDestPath,
-}: InstallTemplateArgs & {
-  backend: boolean;
-  relativeEngineDestPath: string;
-}) => {
+}: 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", "streaming", framework);
+  const copySource = ["**"];
+
+  await copy(copySource, root, {
+    parents: true,
+    cwd: templatePath,
+    rename: assetRelocator,
+  });
+
   /**
    * If next.js is used, update its configuration if necessary
    */
@@ -163,6 +98,10 @@ const installLegacyTSTemplate = async ({
   }
 
   const compPath = path.join(templatesDir, "components");
+  const relativeEngineDestPath =
+    framework === "nextjs"
+      ? path.join("app", "api", "chat")
+      : path.join("src", "controllers");
   const enginePath = path.join(root, relativeEngineDestPath, "engine");
 
   // copy llamaindex code for TS templates
@@ -297,75 +236,6 @@ const installLegacyTSTemplate = async ({
     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,
@@ -378,7 +248,6 @@ export const installTSTemplate = async ({
     vectorDb,
     backend,
     modelConfig,
-    template,
   });
 
   if (
@@ -393,27 +262,27 @@ const providerDependencies: {
   [key in ModelProvider]?: Record<string, string>;
 } = {
   openai: {
-    "@llamaindex/openai": "~0.4.0",
+    "@llamaindex/openai": "^0.1.52",
   },
   gemini: {
-    "@llamaindex/google": "^0.2.0",
+    "@llamaindex/google": "^0.0.7",
   },
   ollama: {
-    "@llamaindex/ollama": "^0.1.0",
+    "@llamaindex/ollama": "^0.0.40",
   },
   mistral: {
-    "@llamaindex/mistral": "^0.2.0",
+    "@llamaindex/mistral": "^0.0.5",
   },
   "azure-openai": {
-    "@llamaindex/openai": "^0.2.0",
+    "@llamaindex/openai": "^0.1.52",
   },
   groq: {
-    "@llamaindex/groq": "^0.0.61",
-    "@llamaindex/huggingface": "^0.1.0", // groq uses huggingface as default embedding model
+    "@llamaindex/groq": "^0.0.51",
+    "@llamaindex/huggingface": "^0.0.36", // 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
+    "@llamaindex/anthropic": "^0.1.0",
+    "@llamaindex/huggingface": "^0.0.36", // anthropic uses huggingface as default embedding model
   },
 };
 
@@ -462,7 +331,6 @@ async function updatePackageJson({
   vectorDb,
   backend,
   modelConfig,
-  template,
 }: Pick<
   InstallTemplateArgs,
   | "root"
@@ -473,7 +341,6 @@ async function updatePackageJson({
   | "observability"
   | "vectorDb"
   | "modelConfig"
-  | "template"
 > & {
   relativeEngineDestPath: string;
   backend: boolean;
@@ -485,7 +352,7 @@ async function updatePackageJson({
   packageJson.name = appName;
   packageJson.version = "0.1.0";
 
-  if (relativeEngineDestPath && template !== "llamaindexserver") {
+  if (relativeEngineDestPath) {
     // TODO: move script to {root}/scripts for all frameworks
     // add generate script if using context engine
     packageJson.scripts = {
@@ -519,7 +386,7 @@ async function updatePackageJson({
   if (backend) {
     packageJson.dependencies = {
       ...packageJson.dependencies,
-      "@llamaindex/readers": "~3.1.4",
+      "@llamaindex/readers": "^2.0.0",
     };
 
     if (vectorDb && vectorDb in vectorDbDependencies) {
@@ -549,16 +416,6 @@ async function updatePackageJson({
     };
   }
 
-  // if having custom server package tgz file, use it for testing @llamaindex/server
-  const serverPackagePath = process.env.SERVER_PACKAGE_PATH;
-  if (serverPackagePath && template === "llamaindexserver") {
-    const relativePath = path.relative(process.cwd(), serverPackagePath);
-    packageJson.dependencies = {
-      ...packageJson.dependencies,
-      "@llamaindex/server": `file:${relativePath}`,
-    };
-  }
-
   await fs.writeFile(
     packageJsonFile,
     JSON.stringify(packageJson, null, 2) + os.EOL,

helpers/validate-pkg.ts

@@ -1,3 +1,4 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
 import validateProjectName from "validate-npm-package-name";
 
 export function validateNpmName(name: string): {

index.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-extraneous-dependencies */
 import { execSync } from "child_process";
 import { Command } from "commander";
 import fs from "fs";
@@ -196,7 +197,7 @@ const program = new Command(packageJson.name)
     "--pro",
     `
 
-  Deprecated: Allow interactive selection of all features.
+  Allow interactive selection of all features.
 `,
     false,
   )

llama-index-server/README.md

@@ -0,0 +1,55 @@
+# LlamaIndex Server
+
+LlamaIndexServer is a FastAPI application that allows you to quickly launch your workflow as an API server.
+
+## Installation
+
+```bash
+pip install llama-index-server
+```
+
+## Usage
+
+```python
+# main.py
+from llama_index.core.agent.workflow import AgentWorkflow
+from llama_index.core.workflow import Workflow
+from llama_index.core.tools import FunctionTool
+from llama_index.server import LlamaIndexServer
+
+
+# Define a factory function that returns a Workflow or AgentWorkflow
+def create_workflow() -> Workflow:
+    def fetch_weather(city: str) -> str:
+        return f"The weather in {city} is sunny"
+
+    return AgentWorkflow.from_tools(
+        tools=[
+            FunctionTool.from_defaults(
+                fn=fetch_weather,
+            )
+        ]
+    )
+
+
+# Create an API server the workflow
+app = LlamaIndexServer(
+    workflow_factory=create_workflow  # Supports Workflow or AgentWorkflow
+)
+```
+
+## Running the server
+
+- In the same directory as `main.py`, run the following command to start the server:
+
+  ```bash
+  fastapi dev
+  ```
+
+- Making a request to the server
+
+  ```bash
+  curl -X POST "http://localhost:8000/api/chat" -H "Content-Type: application/json" -d '{"message": "What is the weather in Tokyo?"}'
+  ```
+
+- See the API documentation at `http://localhost:8000/docs`

llama-index-server/llama_index/server/__init__.py

@@ -0,0 +1,3 @@
+from .server import LlamaIndexServer
+
+__all__ = ["LlamaIndexServer"]

llama-index-server/llama_index/server/api/callbacks/__init__.py

@@ -1,6 +1,4 @@
-from llama_index.server.api.callbacks.agent_call_tool import AgentCallTool
 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
 from llama_index.server.api.callbacks.suggest_next_questions import (
     SuggestNextQuestions,
@@ -10,6 +8,4 @@ __all__ = [
     "EventCallback",
     "SourceNodesFromToolCall",
     "SuggestNextQuestions",
-    "LlamaCloudFileDownload",
-    "AgentCallTool",
 ]

llama-index-server/llama_index/server/api/callbacks/source_nodes.py

@@ -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()

llama-index-server/llama_index/server/api/callbacks/suggest_next_questions.py

@@ -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,
 )

llama-index-server/llama_index/server/api/models.py

@@ -0,0 +1,137 @@
+import logging
+import os
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field, field_validator
+
+from llama_index.core.schema import NodeWithScore
+from llama_index.core.types import ChatMessage, MessageRole
+from llama_index.core.workflow import Event
+
+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]
+    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 = os.getenv("FILESERVER_URL_PREFIX")
+        if not url_prefix:
+            logger.warning(
+                "Warning: FILESERVER_URL_PREFIX not set in environment variables. Can't use file server"
+            )
+        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]

llama-index-server/llama_index/server/api/routers/chat.py

@@ -0,0 +1,109 @@
+import asyncio
+import logging
+from typing import AsyncGenerator, Callable, Union
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+
+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 (
+    SourceNodesFromToolCall,
+    SuggestNextQuestions,
+)
+from llama_index.server.api.callbacks.base import EventCallback
+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
+
+
+def chat_router(
+    workflow_factory: Callable[..., Workflow],
+    logger: logging.Logger,
+) -> APIRouter:
+    router = APIRouter(prefix="/chat")
+
+    @router.post("")
+    async def chat(request: ChatRequest) -> StreamingResponse:
+        try:
+            user_message = request.messages[-1].to_llamaindex_message()
+            chat_history = [
+                message.to_llamaindex_message() for message in request.messages[:-1]
+            ]
+            workflow = workflow_factory()
+            workflow_handler = workflow.run(
+                user_msg=user_message.content,
+                chat_history=chat_history,
+            )
+
+            callbacks: list[EventCallback] = [
+                SourceNodesFromToolCall(),
+            ]
+            if request.config and request.config.next_question_suggestions:
+                callbacks.append(SuggestNextQuestions(request))
+            stream_handler = StreamHandler(
+                workflow_handler=workflow_handler,
+                callbacks=callbacks,
+            )
+
+            return VercelStreamResponse(
+                content_generator=_stream_content(stream_handler, request, logger),
+            )
+        except Exception as e:
+            logger.error(e)
+            raise HTTPException(status_code=500, detail=str(e))
+
+    return router
+
+
+async def _stream_content(
+    handler: StreamHandler,
+    request: ChatRequest,
+    logger: logging.Logger,
+) -> AsyncGenerator[str, None]:
+    async def _text_stream(
+        event: Union[AgentStream, StopEvent],
+    ) -> AsyncGenerator[str, None]:
+        if isinstance(event, AgentStream):
+            if event.delta.strip():  # Only yield non-empty deltas
+                yield event.delta
+        elif isinstance(event, StopEvent):
+            if isinstance(event.result, str):
+                yield event.result
+            elif isinstance(event.result, AsyncGenerator):
+                async for chunk in event.result:
+                    if isinstance(chunk, str):
+                        yield chunk
+                    elif (
+                        hasattr(chunk, "delta") and chunk.delta.strip()
+                    ):  # Only yield non-empty deltas
+                        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, dict):
+                yield VercelStreamResponse.convert_data(event)
+            elif hasattr(event, "to_response"):
+                event_response = event.to_response()
+                yield VercelStreamResponse.convert_data(event_response)
+            else:
+                yield VercelStreamResponse.convert_data(event.model_dump())
+
+    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}")
+        yield VercelStreamResponse.convert_error(str(e))
+        await handler.cancel_run()

llama-index-server/llama_index/server/chat_ui.py

@@ -0,0 +1,55 @@
+import logging
+import shutil
+from pathlib import Path
+from typing import Optional
+
+import requests
+
+CHAT_UI_VERSION = "0.0.2"
+
+
+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)

llama-index-server/llama_index/server/server.py

@@ -0,0 +1,134 @@
+import logging
+import os
+from typing import Any, Callable, Optional
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+from llama_index.core.workflow import Workflow
+from llama_index.server.api.routers.chat import chat_router
+from llama_index.server.chat_ui import download_chat_ui
+
+
+class LlamaIndexServer(FastAPI):
+    workflow_factory: Callable[..., Workflow]
+    api_prefix: str = "/api"
+    include_ui: Optional[bool]
+    verbose: bool = False
+    ui_path: str = ".ui"
+
+    def __init__(
+        self,
+        workflow_factory: Callable[..., Workflow],
+        logger: Optional[logging.Logger] = None,
+        use_default_routers: Optional[bool] = False,
+        env: Optional[str] = None,
+        include_ui: Optional[bool] = None,
+        verbose: bool = False,
+        *args: Any,
+        **kwargs: Any,
+    ):
+        """
+        Initialize the LlamaIndexServer.
+
+        Args:
+            workflow_factory: A factory function that creates a workflow instance for each request.
+            logger: The logger to use.
+            use_default_routers: Whether to use the default routers (chat, mount `data` and `output` directories).
+            env: The environment to run the server in.
+            include_ui: Whether to show an chat UI in the root path.
+            verbose: Whether to show verbose logs.
+        """
+        super().__init__(*args, **kwargs)
+
+        self.workflow_factory = workflow_factory
+        self.logger = logger or logging.getLogger("uvicorn")
+        self.verbose = verbose
+        self.include_ui = include_ui  # Store the explicitly passed value first
+
+        if use_default_routers:
+            self.add_default_routers()
+
+        if str(env).lower() == "dev":
+            self.allow_cors("*")
+            if self.include_ui is None:
+                self.include_ui = True
+        if self.include_ui is None:
+            self.include_ui = False
+
+        if self.include_ui:
+            self.mount_ui()
+
+    # Default routers
+    def add_default_routers(self) -> None:
+        self.add_chat_router()
+        self.mount_data_dir()
+        self.mount_output_dir()
+
+    def add_chat_router(self) -> None:
+        """
+        Add the chat router.
+        """
+        self.include_router(
+            chat_router(
+                self.workflow_factory,
+                self.logger,
+            ),
+            prefix=self.api_prefix,
+        )
+
+    def mount_ui(self) -> None:
+        """
+        Mount the UI.
+        """
+        # Check if the static folder exists
+        if self.include_ui:
+            if not os.path.exists(self.ui_path):
+                self.logger.warning(
+                    f"UI files not found, downloading UI to {self.ui_path}"
+                )
+                download_chat_ui(logger=self.logger, target_path=self.ui_path)
+            self._mount_static_files(directory=self.ui_path, path="/", html=True)
+
+    def mount_data_dir(self, data_dir: str = "data") -> None:
+        """
+        Mount the data directory.
+        """
+        self._mount_static_files(
+            directory=data_dir, path=f"{self.api_prefix}/files/data", html=True
+        )
+
+    def mount_output_dir(self, output_dir: str = "output") -> None:
+        """
+        Mount the output directory.
+        """
+        self._mount_static_files(
+            directory=output_dir, path=f"{self.api_prefix}/files/output", html=True
+        )
+
+    def _mount_static_files(
+        self, directory: str, path: str, html: bool = False
+    ) -> None:
+        """
+        Mount static files from a directory if it exists.
+        """
+        if os.path.exists(directory):
+            self.logger.info(f"Mounting static files '{directory}' at '{path}'")
+            self.mount(
+                path,
+                StaticFiles(directory=directory, check_dir=False, html=html),
+                name=f"{directory}-static",
+            )
+
+    def allow_cors(self, origin: str = "*") -> None:
+        """
+        Allow CORS for a specific origin.
+        """
+        self.add_middleware(
+            CORSMiddleware,
+            allow_origins=[origin],
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )

llama-index-server/llama_index/server/services/file.py

@@ -5,7 +5,6 @@ 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__)
@@ -86,10 +85,20 @@ class FileService:
 
         logger.info(f"Saved file to {file_path}")
 
+        file_url_prefix = os.getenv("FILESERVER_URL_PREFIX")
+        if file_url_prefix is None:
+            logger.warning(
+                "FILESERVER_URL_PREFIX is not set. Some features may not work correctly."
+            )
+            file_url_prefix = "http://localhost:8000/api/files"
         file_size = os.path.getsize(file_path)
-        file_url = (
-            f"{server_settings.file_server_url_prefix}/{save_dir}/{new_file_name}"
+
+        file_url = os.path.join(
+            file_url_prefix,
+            save_dir,
+            new_file_name,
         )
+
         return DocumentFile(
             id=file_id,
             name=new_file_name,
@@ -100,15 +109,6 @@ class FileService:
             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:
     """

llama-index-server/llama_index/server/services/suggest_next_question.py

@@ -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

llama-index-server/llama_index/server/tools/document_generator.py

@@ -99,11 +99,6 @@ HTML_TEMPLATE = """
 
 
 class DocumentGenerator:
-    def __init__(self, file_server_url_prefix: str):
-        if not file_server_url_prefix:
-            raise ValueError("file_server_url_prefix is required")
-        self.file_server_url_prefix = file_server_url_prefix
-
     @classmethod
     def _generate_html_content(cls, original_content: str) -> str:
         """
@@ -160,8 +155,9 @@ class DocumentGenerator:
             content=html_content,
         )
 
+    @classmethod
     def generate_document(
-        self, original_content: str, document_type: str, file_name: str
+        cls, original_content: str, document_type: str, file_name: str
     ) -> str:
         """
         To generate document as PDF or HTML file.
@@ -179,26 +175,24 @@ class DocumentGenerator:
                 f"Invalid document type: {document_type}. Must be 'pdf' or 'html'."
             )
         # Always generate html content first
-        html_content = self._generate_html_content(original_content)
+        html_content = cls._generate_html_content(original_content)
 
         # Based on the type of document, generate the corresponding file
         if doc_type == DocumentType.PDF:
-            content = self._generate_pdf(html_content)
+            content = cls._generate_pdf(html_content)
             file_extension = "pdf"
         elif doc_type == DocumentType.HTML:
-            content = BytesIO(self._generate_html(html_content).encode("utf-8"))
+            content = BytesIO(cls._generate_html(html_content).encode("utf-8"))
             file_extension = "html"
         else:
             raise ValueError(f"Unexpected document type: {document_type}")
 
-        file_name = self._validate_file_name(file_name)
+        file_name = cls._validate_file_name(file_name)
         file_path = os.path.join(OUTPUT_DIR, f"{file_name}.{file_extension}")
 
-        self._write_to_file(content, file_path)
+        cls._write_to_file(content, file_path)
 
-        return (
-            f"{self.file_server_url_prefix}/{OUTPUT_DIR}/{file_name}.{file_extension}"
-        )
+        return f"{os.getenv('FILESERVER_URL_PREFIX')}/{OUTPUT_DIR}/{file_name}.{file_extension}"
 
     @staticmethod
     def _write_to_file(content: BytesIO, file_path: str) -> None:

llama-index-server/llama_index/server/tools/index/__init__.py

@@ -0,0 +1,3 @@
+from .query import get_query_engine_tool
+
+__all__ = ["get_query_engine_tool"]

llama-index-server/llama_index/server/tools/index/query.py

@@ -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

llama-index-server/llama_index/server/tools/interpreter.py

@@ -4,9 +4,10 @@ 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.services.file import DocumentFile, FileService
-from pydantic import BaseModel
 
 logger = logging.getLogger("uvicorn")
 
@@ -33,24 +34,34 @@ class E2BCodeInterpreter:
 
     def __init__(
         self,
-        api_key: str,
+        api_key: Optional[str] = None,
+        filesever_url_prefix: Optional[str] = None,
         output_dir: Optional[str] = None,
         uploaded_files_dir: Optional[str] = None,
     ):
         """
         Args:
-            api_key: The API key for the E2B Code Interpreter.
+            api_key: The API key for the E2B Code Interpreter. If not provided, it will be read from the environment variable `E2B_API_KEY`.
+            filesever_url_prefix: The prefix for the file server or loaded from env: `FILESERVER_URL_PREFIX`, default is `/api/files`.
             output_dir: The directory for the output files. Default is `output/tools`.
             uploaded_files_dir: The directory for the files to be uploaded to the sandbox. Default is `output/uploaded`.
         """
         self._validate_package()
+        if api_key is None:
+            api_key = os.getenv("E2B_API_KEY")
+        if filesever_url_prefix is None:
+            filesever_url_prefix = os.getenv("FILESERVER_URL_PREFIX", "/api/files")
         if not api_key:
             raise ValueError(
-                "api_key is required to run code interpreter. Get it here: https://e2b.dev/docs/getting-started/api-key"
+                "E2B_API_KEY key is required to run code interpreter. Get it here: https://e2b.dev/docs/getting-started/api-key"
             )
+        if output_dir is not None:
+            self.output_dir = output_dir
+        if uploaded_files_dir is not None:
+            self.uploaded_files_dir = uploaded_files_dir
+        self.filesever_url_prefix = filesever_url_prefix
+        self.interpreter = None
         self.api_key = api_key
-        self.output_dir = output_dir or "output/tools"
-        self.uploaded_files_dir = uploaded_files_dir or "output/uploaded"
 
     @classmethod
     def _validate_package(cls) -> None:

llama-index-server/llama_index/server/utils/agent_tool.py

@@ -1,11 +1,11 @@
 import logging
 import uuid
 from abc import ABC, abstractmethod
-from typing import Any, AsyncGenerator, Optional
+from typing import Any, AsyncGenerator, Callable, Optional
 
 from pydantic import BaseModel, ConfigDict
 
-from llama_index.core.base.llms.types import ChatMessage, ChatResponse
+from llama_index.core.base.llms.types import ChatMessage, ChatResponse, MessageRole
 from llama_index.core.llms.function_calling import FunctionCallingLLM
 from llama_index.core.tools import (
     BaseTool,
@@ -14,12 +14,11 @@ 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")
 
-
 class ToolCallOutput(BaseModel):
     tool_call_id: str
     tool_output: ToolOutput
@@ -119,7 +118,11 @@ async def call_tools(
                 )
             )
         return [
-            await call_tool(ctx, tools_by_name[tool_calls[0].tool_name], tool_calls[0])
+            await call_tool(
+                ctx,
+                tools_by_name[tool_calls[0].tool_name],
+                tool_calls[0]
+            )
         ]
     # Multiple tool calls, show progress
     tool_call_outputs: list[ToolCallOutput] = []
@@ -147,7 +150,7 @@ async def call_tools(
                         raw_output={
                             "error": f"Tool {tool_call.tool_name} does not exist",
                         },
-                    ),
+                    )
                 )
             )
             continue
@@ -219,7 +222,6 @@ async def call_tool(
         tool_output=output,
     )
 
-
 async def _tool_call_generator(
     llm: FunctionCallingLLM,
     tools: list[BaseTool],

llama-index-server/pyproject.toml

@@ -0,0 +1,61 @@
+[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.0"
+
+[tool.poetry.dependencies]
+python = ">=3.9,<4.0"
+fastapi = {extras = ["standard"], version = "^0.115.11"}
+cachetools = "^5.5.2"
+requests = "^2.32.3"
+llama-index-core = "^0.12.0"
+llama-index-readers-file = "^0.4.6"
+
+[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-index-server/tests/api/test_chat_api.py

@@ -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()
@@ -96,14 +90,14 @@ async def test_chat_router(
 
 
 @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."
         )
@@ -112,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
@@ -122,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

llama-index-server/tests/api/test_event_stream.py

@@ -1,34 +1,29 @@
 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()
     return handler
@@ -37,11 +32,8 @@ def mock_workflow_handler() -> AsyncMock:
 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()
@@ -51,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()
@@ -76,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()
@@ -100,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()
@@ -125,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()
@@ -149,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
             )
         ]
 
@@ -183,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
             )
         ]
 
@@ -207,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=""
         )
@@ -215,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="",
@@ -240,30 +217,31 @@ 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")
             yield ObjectWithDelta("Delta 2")
+            yield ObjectWithDelta("  ")  # Should be filtered out by strip check
 
         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

llama-index-server/tests/services/test_file_service.py

@@ -3,6 +3,7 @@ import uuid
 from unittest.mock import mock_open, patch
 
 import pytest
+
 from llama_index.server.services.file import FileService, _sanitize_file_name
 
 
@@ -53,7 +54,7 @@ class TestFileService:
         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.url.endswith(expected_path)
         assert result.refs is None
 
     @patch("uuid.uuid4")
@@ -143,7 +144,7 @@ class TestFileService:
         test_uuid = "12345678-1234-5678-1234-567812345678"
         mock_uuid.return_value = uuid.UUID(test_uuid)
         mock_getsize.return_value = 11
-        mock_getenv.return_value = "/api/files"
+        mock_getenv.return_value = "https://custom-url.com/files"
 
         # Execute
         result = FileService.save_file(
@@ -157,8 +158,9 @@ class TestFileService:
         )
         mock_file_open.assert_called_once_with(expected_path, "wb")
         assert result.path == expected_path
-        # URL paths must use forward slashes, even on Windows
-        expected_url = f"/api/files/test_dir/test_{test_uuid}.txt"
+        expected_url = os.path.join(
+            "https://custom-url.com/files", "test_dir", f"test_{test_uuid}.txt"
+        )
         assert result.url == expected_url
 
     def test_save_file_no_extension(self):

llama-index-server/tests/test_llamaindex_server.py

@@ -0,0 +1,106 @@
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+from llama_index.core.agent.workflow import AgentWorkflow
+from llama_index.core.llms import MockLLM
+from llama_index.server import LlamaIndexServer
+
+
+def fetch_weather(city: str) -> str:
+    """Fetch the weather for a given city."""
+    return f"The weather in {city} is sunny."
+
+
+def _agent_workflow() -> AgentWorkflow:
+    # Use MockLLM instead of default OpenAI
+    mock_llm = MockLLM()
+    return AgentWorkflow.from_tools_or_functions(
+        tools_or_functions=[fetch_weather],
+        verbose=True,
+        llm=mock_llm,
+    )
+
+
+@pytest.fixture()
+def server() -> LlamaIndexServer:
+    """Fixture to create a LlamaIndexServer instance."""
+    return LlamaIndexServer(
+        workflow_factory=_agent_workflow,
+        verbose=True,
+        use_default_routers=True,
+        mount_ui=False,
+        env="dev",
+    )
+
+
+@pytest.mark.asyncio()
+async def test_server_has_chat_route(server: LlamaIndexServer) -> None:
+    """Test that the server has the chat API route."""
+    chat_route_exists = any(route.path == "/api/chat" for route in server.routes)
+    assert chat_route_exists, "Chat API route not found in server routes"
+
+
+@pytest.mark.asyncio()
+async def test_server_swagger_docs(server: LlamaIndexServer) -> None:
+    """Test that the server serves Swagger UI docs."""
+    async with AsyncClient(
+        transport=ASGITransport(app=server), base_url="http://test"
+    ) as ac:
+        response = await ac.get("/docs")
+        assert response.status_code == 200
+        assert "text/html" in response.headers["content-type"]
+        assert "Swagger UI" in response.text
+
+
+@pytest.mark.asyncio()
+async def test_ui_is_downloaded(server: LlamaIndexServer) -> None:
+    """
+    Test if the UI is downloaded and mounted correctly.
+    """
+    import os
+    import shutil
+
+    # Clean up any existing static directory first
+    if os.path.exists(".ui"):
+        shutil.rmtree(".ui")
+
+    # Create a new server with UI enabled
+    ui_server = LlamaIndexServer(
+        workflow_factory=_agent_workflow,
+        verbose=True,
+        use_default_routers=True,
+        env="dev",
+        include_ui=True,
+    )
+
+    # Verify that static directory was created with index.html
+    assert os.path.exists("./.ui"), "Static directory was not created"
+    assert os.path.isdir("./.ui"), "Static path is not a directory"
+    assert os.path.exists("./.ui/index.html"), "index.html was not downloaded"
+
+    # Check if the UI is mounted and accessible
+    async with AsyncClient(
+        transport=ASGITransport(app=ui_server), base_url="http://test"
+    ) as ac:
+        response = await ac.get("/")
+        assert response.status_code == 200
+        assert "text/html" in response.headers["content-type"]
+
+    # Clean up after test
+    shutil.rmtree("./.ui")
+
+
+@pytest.mark.asyncio()
+async def test_ui_is_accessible(server: LlamaIndexServer) -> None:
+    """
+    Test if the UI is accessible.
+    """
+    # Manually trigger UI mounting
+    server.mount_ui()
+
+    async with AsyncClient(
+        transport=ASGITransport(app=server), base_url="http://test"
+    ) as ac:
+        response = await ac.get("/")
+        assert response.status_code == 200
+        assert "text/html" in response.headers["content-type"]

llama-index-server/tests/tools/test_document_generator.py

@@ -1,7 +1,9 @@
+import os
 from io import BytesIO
 from unittest.mock import MagicMock, patch
 
 import pytest
+
 from llama_index.server.tools.document_generator import (
     OUTPUT_DIR,
     DocumentGenerator,
@@ -9,22 +11,25 @@ from llama_index.server.tools.document_generator import (
 
 
 class TestDocumentGenerator:
+    @pytest.fixture()
+    def env_setup(self):  # type: ignore
+        os.environ["FILESERVER_URL_PREFIX"] = "http://test-server"
+        yield
+        os.environ.pop("FILESERVER_URL_PREFIX", None)
+
     def test_validate_file_name(self) -> None:
         # Valid names
-        assert (
-            DocumentGenerator("/api/files")._validate_file_name("valid-name")
-            == "valid-name"
-        )
+        assert DocumentGenerator._validate_file_name("valid-name") == "valid-name"
 
         # Invalid names
         with pytest.raises(ValueError):
-            DocumentGenerator("/api/files")._validate_file_name("/invalid/path")
+            DocumentGenerator._validate_file_name("/invalid/path")
 
     @patch("os.makedirs")
     @patch("builtins.open")
     def test_write_to_file(self, mock_open, mock_makedirs):  # type: ignore
         content = BytesIO(b"test")
-        DocumentGenerator("/api/files")._write_to_file(content, "path/file.txt")
+        DocumentGenerator._write_to_file(content, "path/file.txt")
 
         mock_makedirs.assert_called_once()
         mock_open.assert_called_once()
@@ -37,13 +42,10 @@ class TestDocumentGenerator:
         mock_markdown.return_value = "<h1>Test</h1>"
 
         # Test HTML content generation
-        assert (
-            DocumentGenerator("/api/files")._generate_html_content("# Test")
-            == "<h1>Test</h1>"
-        )
+        assert DocumentGenerator._generate_html_content("# Test") == "<h1>Test</h1>"
 
         # Test full HTML generation
-        html = DocumentGenerator("/api/files")._generate_html("<h1>Test</h1>")
+        html = DocumentGenerator._generate_html("<h1>Test</h1>")
         assert "<!DOCTYPE html>" in html
         assert "<h1>Test</h1>" in html
 
@@ -51,14 +53,12 @@ class TestDocumentGenerator:
     def test_pdf_generation(self, mock_pisa):  # type: ignore
         # Success case
         mock_pisa.return_value = MagicMock(err=None)
-        assert isinstance(
-            DocumentGenerator("/api/files")._generate_pdf("test"), BytesIO
-        )
+        assert isinstance(DocumentGenerator._generate_pdf("test"), BytesIO)
 
         # Error case
         mock_pisa.return_value = MagicMock(err="Error")
         with pytest.raises(ValueError):
-            DocumentGenerator("/api/files")._generate_pdf("test")
+            DocumentGenerator._generate_pdf("test")
 
     @patch.multiple(
         DocumentGenerator,
@@ -69,21 +69,21 @@ class TestDocumentGenerator:
         _generate_pdf=MagicMock(return_value=BytesIO(b"pdf")),
         _write_to_file=MagicMock(),
     )
-    def test_generate_document(self):  # type: ignore
+    def test_generate_document(self, env_setup):  # type: ignore
         # HTML generation
-        url = DocumentGenerator("/api/files").generate_document(
-            "# Test", "html", "test-doc"
-        )
-        assert url == f"/api/files/{OUTPUT_DIR}/test-doc.html"
+        url = DocumentGenerator.generate_document("# Test", "html", "test-doc")
+        assert url == f"http://test-server/{OUTPUT_DIR}/test-doc.html"
 
         # PDF generation
-        url = DocumentGenerator("/api/files").generate_document(
-            "# Test", "pdf", "test-doc"
-        )
-        assert url == f"/api/files/{OUTPUT_DIR}/test-doc.pdf"
+        url = DocumentGenerator.generate_document("# Test", "pdf", "test-doc")
+        assert url == f"http://test-server/{OUTPUT_DIR}/test-doc.pdf"
 
         # Invalid type
         with pytest.raises(ValueError):
-            DocumentGenerator("/api/files").generate_document(
-                "# Test", "invalid", "test-doc"
-            )
+            DocumentGenerator.generate_document("# Test", "invalid", "test-doc")
+
+    def test_to_tool(self):  # type: ignore
+        tool = DocumentGenerator().to_tool()
+        # Check the function is correct
+        assert tool.fn == DocumentGenerator.generate_document
+        assert callable(tool.fn)

llama-index-server/tests/tools/test_interpreter.py

@@ -1,7 +1,9 @@
-from unittest.mock import MagicMock
+import os
+from unittest.mock import MagicMock, patch
 
 import pytest
 from e2b_code_interpreter.models import Execution, Logs
+
 from llama_index.server.tools.interpreter import E2BCodeInterpreter
 
 
@@ -18,9 +20,10 @@ class TestE2BCodeInterpreter:
     @pytest.fixture()
     def code_interpreter(self, sandbox):  # type: ignore
         """Create E2BCodeInterpreter that uses the mock Sandbox."""
-        interpreter = E2BCodeInterpreter(api_key="dummy_key")
-        interpreter.interpreter = sandbox
-        return interpreter
+        with patch.dict(os.environ, {"E2B_API_KEY": "dummy_key"}):
+            interpreter = E2BCodeInterpreter()
+            interpreter.interpreter = sandbox
+            return interpreter
 
     def test_interpret_success(self, code_interpreter, sandbox) -> None:  # type: ignore
         """Test successful code execution."""

package.json

@@ -1,55 +1,83 @@
 {
-  "name": "create-llama-monorepo",
-  "version": "1.0.0",
-  "private": true,
-  "description": "Monorepo for create-llama",
+  "name": "create-llama",
+  "version": "0.4.0",
+  "description": "Create LlamaIndex-powered apps with one command",
   "keywords": [
     "rag",
-    "llamaindex"
+    "llamaindex",
+    "next.js"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/run-llama/create-llama"
+    "url": "https://github.com/run-llama/create-llama",
+    "directory": "packages/create-llama"
   },
   "license": "MIT",
-  "workspaces": [
-    "packages/*",
-    "python/*"
+  "bin": {
+    "create-llama": "./dist/index.js"
+  },
+  "files": [
+    "dist"
   ],
   "scripts": {
-    "dev": "pnpm -r dev",
-    "build": "pnpm -r build",
-    "e2e": "pnpm -r e2e",
-    "lint": "eslint .",
+    "build": "bash ./scripts/build.sh",
+    "build:ncc": "pnpm run clean && ncc build ./index.ts -o ./dist/ --minify --no-cache --no-source-map-register",
+    "clean": "rimraf --glob ./dist ./templates/**/__pycache__ ./templates/**/node_modules ./templates/**/poetry.lock",
+    "dev": "ncc build ./index.ts -w -o dist/",
+    "e2e": "playwright test",
+    "e2e:python": "playwright test e2e/shared e2e/python",
+    "e2e:typescript": "playwright test e2e/shared e2e/typescript",
     "format": "prettier --ignore-unknown --cache --check .",
     "format:write": "prettier --ignore-unknown --write .",
+    "lint": "eslint . --ignore-pattern dist --ignore-pattern e2e/cache",
+    "new-snapshot": "pnpm run build && changeset version --snapshot",
+    "new-version": "pnpm run build && changeset version",
+    "pack-install": "bash ./scripts/pack.sh",
     "prepare": "husky",
-    "new-snapshot": "pnpm -r build && changeset version --snapshot",
-    "new-version-python": "pnpm --filter @create-llama/llama-index-server new-version",
-    "new-version": "pnpm -r build && changeset version && pnpm new-version-python",
-    "release-python": "pnpm --filter @create-llama/llama-index-server release",
-    "release": "pnpm -r build && changeset publish && pnpm release-python",
-    "release-snapshot": "pnpm -r build && changeset publish --tag snapshot"
+    "release": "pnpm run build && changeset publish",
+    "release-snapshot": "pnpm run build && changeset publish --tag snapshot"
+  },
+  "dependencies": {
+    "@types/async-retry": "1.4.2",
+    "@types/ci-info": "2.0.0",
+    "@types/cross-spawn": "6.0.0",
+    "@types/fs-extra": "11.0.4",
+    "@types/node": "^20.11.7",
+    "@types/prompts": "2.4.2",
+    "@types/tar": "6.1.5",
+    "@types/validate-npm-package-name": "3.0.0",
+    "async-retry": "1.3.1",
+    "async-sema": "3.0.1",
+    "ci-info": "github:watson/ci-info#f43f6a1cefff47fb361c88cf4b943fdbcaafe540",
+    "commander": "12.1.0",
+    "cross-spawn": "7.0.3",
+    "fast-glob": "3.3.1",
+    "fs-extra": "11.2.0",
+    "global-agent": "^3.0.0",
+    "got": "10.7.0",
+    "ollama": "^0.5.0",
+    "ora": "^8.0.1",
+    "picocolors": "1.0.0",
+    "prompts": "2.4.2",
+    "smol-toml": "^1.1.4",
+    "tar": "6.1.15",
+    "terminal-link": "^3.0.0",
+    "update-check": "1.5.4",
+    "validate-npm-package-name": "3.0.0",
+    "yaml": "2.4.1"
   },
   "devDependencies": {
     "@changesets/cli": "^2.27.1",
-    "bunchee": "6.4.0",
+    "@playwright/test": "^1.41.1",
+    "@vercel/ncc": "0.38.1",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^8.10.0",
     "husky": "^9.0.10",
-    "lint-staged": "^15.2.11",
-    "typescript-eslint": "^8.18.0",
-    "globals": "^15.12.0",
-    "eslint": "9.22.0",
-    "@eslint/js": "^9.25.0",
-    "eslint-config-next": "^15.1.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-react": "7.37.2",
-    "prettier": "^3.4.2",
-    "prettier-plugin-organize-imports": "^4.1.0",
-    "prettier-plugin-tailwindcss": "^0.6.11",
-    "typescript": "^5.7.3",
-    "@types/node": "^22.9.0",
-    "@types/react": "^19",
-    "@types/react-dom": "^19"
+    "prettier": "^3.2.5",
+    "prettier-plugin-organize-imports": "^3.2.4",
+    "rimraf": "^5.0.5",
+    "typescript": "^5.3.3",
+    "wait-port": "^1.1.0"
   },
   "packageManager": "pnpm@9.0.5",
   "engines": {

packages/create-llama/.gitignore

@@ -1,65 +0,0 @@
-# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
-
-# dependencies
-node_modules
-.pnp
-.pnpm-store
-.pnp.js
-
-# testing
-coverage
-.coverage
-
-# next.js
-.next/
-out/
-build
-
-# misc
-.DS_Store
-*.pem
-
-# debug
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# local env files
-.env
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-
-# build
-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
-
-# copied from root
-README.md
-LICENSE.md

packages/create-llama/CLAUDE.md

@@ -1,108 +0,0 @@
-# create-llama Package
-
-## Overview
-
-The `create-llama` package is a CLI tool for creating LlamaIndex-powered applications with one command. It's designed as a project generator that scaffolds various types of RAG (Retrieval-Augmented Generation) applications using different frameworks, databases, and AI model providers.
-
-## Package Structure
-
-### Core Files
-
-- **`index.ts`**: Main CLI entry point using Commander.js for argument parsing
-- **`create-app.ts`**: Core application creation logic and orchestration
-- **`package.json`**: Package configuration with binary entry point at `./dist/index.js`
-
-### Key Directories
-
-- **`helpers/`**: Utility functions for package management, file operations, and configuration
-- **`questions/`**: Interactive prompts for user configuration
-- **`templates/`**: Project templates for different frameworks and use cases
-- **`e2e/`**: End-to-end tests using Playwright
-
-## Core Functionality
-
-### CLI Interface
-
-The tool accepts numerous command-line options including:
-
-- Framework selection (`--framework`: nextjs, express, fastapi)
-- Template type (`--template`: streaming, multiagent, reflex, llamaindexserver)
-- Model providers (OpenAI, Anthropic, Groq, Ollama, etc.)
-- Vector databases (none, mongo, pg, pinecone, milvus, etc.)
-- Data sources (files, web URLs, databases)
-- Tools and observability options
-
-### Application Generation Flow
-
-1. **Project validation**: Checks project name validity and directory permissions
-2. **Interactive questioning**: Prompts user for configuration if not provided via CLI
-3. **Template installation**: Copies and configures appropriate templates
-4. **Environment setup**: Creates `.env` files with API keys and configuration
-5. **Dependencies**: Installs packages using detected/specified package manager
-6. **Post-install actions**: Can run the app, open VSCode, or install dependencies
-
-### Template System
-
-Templates are organized by:
-
-- **Framework**: NextJS (frontend), Express (Node backend), FastAPI (Python backend)
-- **Type**: Streaming chat, multiagent workflows, Reflex UI, LlamaIndex server
-- **Components**: Engines, loaders, providers, UI components, observability
-
-### Helper Functions
-
-Key helper modules include:
-
-- **Installation**: Package manager detection and dependency installation
-- **Data sources**: File copying, web scraping, database connection setup
-- **Providers**: Model provider configuration (OpenAI, Anthropic, etc.)
-- **Tools**: Integration with external tools (Wikipedia, weather, code generation)
-- **Environment**: `.env` file generation with API keys and settings
-
-## Development Commands
-
-### Build & Development
-
-- `npm run build`: Build the CLI using bash script
-- `npm run dev`: Watch mode development build
-- `npm run clean`: Clean build artifacts and temporary files
-
-### Testing
-
-- `npm run e2e`: Run all end-to-end tests
-- `npm run e2e:python`: Test Python-specific templates
-- `npm run e2e:typescript`: Test TypeScript-specific templates
-
-### Package Management
-
-- `npm run pack-install`: Create and install local package for testing
-
-## Architecture Notes
-
-### Model Configuration
-
-The tool supports multiple AI providers with a unified `ModelConfig` interface that includes:
-
-- Provider selection and API key management
-- Model and embedding model specification
-- Dimension configuration for embeddings
-
-### Data Source Handling
-
-Flexible data source configuration supporting:
-
-- Local files and directories
-- Web URLs with configurable crawling depth
-- Database connections with custom queries
-- Automatic file downloading and copying
-
-### Template Flexibility
-
-Templates use a component-based system allowing mix-and-match of:
-
-- Different frameworks (NextJS, Express, FastAPI)
-- Various vector databases
-- Multiple observability tools
-- Configurable tools and integrations
-
-This package serves as the foundation for rapidly prototyping and deploying LlamaIndex applications across different technology stacks and use cases.

packages/create-llama/e2e/python/resolve_dependencies.spec.ts

@@ -1,285 +0,0 @@
-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, TemplateType, TemplateUseCase, 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 templateType: TemplateType = process.env.TEMPLATE_TYPE
-  ? (process.env.TEMPLATE_TYPE as TemplateType)
-  : "llamaindexserver";
-const useCases: TemplateUseCase[] = [
-  "agentic_rag",
-  "deep_research",
-  "financial_report",
-  "code_generator",
-  "document_generator",
-];
-const dataSource: string = process.env.DATASOURCE
-  ? process.env.DATASOURCE
-  : "--example-file";
-
-test.describe("Mypy check", () => {
-  test.describe.configure({ retries: 0 });
-
-    // Test for streaming template
-    test.describe("StreamingTemplate", () => {
-      test.skip(templateType !== "streaming", `skipping streaming test for ${templateType}`);
-      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 vector databases
-        for (const vectorDb of vectorDbs) {
-          test(`vectorDB: ${vectorDb} ${templateType}`, 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(`tool: ${tool} ${templateType}`, 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) {
-          test(`data source: ${dataSource} ${templateType}`, async () => {
-          const dataSourceType = dataSource.split(" ")[0];
-            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.describe(`observability: ${observability} ${templateType}`, 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,
-              },
-            });
-          });
-        }
-      }
-    });
-
-    test.describe("LlamaIndexServer", async () => {
-      test.skip(templateType !== "llamaindexserver", `skipping llamaindexserver test for ${templateType}`);
-      test.skip(dataSource !== "--example-file", `skipping llamaindexserver test for ${dataSource}`);
-      for (const useCase of useCases) {
-        const cwd = await createTestDir();
-        await createAndCheckLlamaProject({
-          options: {
-            cwd,
-            templateType: "llamaindexserver",
-            templateFramework,
-            dataSource,
-            vectorDb: "none",
-            tools: "none",
-            port: 3000,
-            postInstallAction: "none",
-            templateUI: undefined,
-            appType: "--no-frontend",
-            llamaCloudProjectName: undefined,
-            llamaCloudIndexName: undefined,
-            observability: undefined,
-            useCase,
-          },
-        });
-      }
-    });
-
-    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();
-
-      // Modify environment for the command
-      const commandEnv = {
-        ...process.env,
-      };
-
-      console.log("Running uv venv...");
-      try {
-        const { stdout: venvStdout, stderr: venvStderr } = await execAsync(
-          "uv venv",
-          { cwd: projectPath, env: commandEnv },
-        );
-        console.log("uv venv stdout:", venvStdout);
-        console.error("uv venv stderr:", venvStderr);
-      } catch (error) {
-        console.error("Error running uv venv:", error);
-        throw error; // Re-throw error to fail the test
-      }
-
-      console.log("Running uv sync...");
-      try {
-        const { stdout: syncStdout, stderr: syncStderr } = await execAsync(
-          "uv sync --all-extras",
-          { cwd: projectPath, env: commandEnv },
-        );
-        console.log("uv sync stdout:", syncStdout);
-        console.error("uv sync stderr:", syncStderr);
-      } catch (error) {
-        console.error("Error running uv sync:", error);
-        throw error; // Re-throw error to fail the test
-      }
-
-      console.log("Running uv run mypy ....");
-      try {
-        const { stdout: mypyStdout, stderr: mypyStderr } = await execAsync(
-          "uv run mypy .",
-          { cwd: projectPath, env: commandEnv },
-        );
-        console.log("uv run mypy stdout:", mypyStdout);
-        console.error("uv run mypy stderr:", mypyStderr);
-        // Assuming mypy success means no output or specific success message
-        // Adjust checks based on actual expected mypy output
-      } 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 };
-  }
-});

packages/create-llama/e2e/typescript/resolve_dependencies.spec.ts

@@ -1,161 +0,0 @@
-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,
-  TemplateType,
-  TemplateUseCase,
-  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 templateType: TemplateType = process.env.TEMPLATE_TYPE
-  ? (process.env.TEMPLATE_TYPE as TemplateType)
-  : "llamaindexserver";
-const useCases: TemplateUseCase[] = [
-  "agentic_rag",
-  "deep_research",
-  "financial_report",
-  "code_generator",
-  "document_generator",
-];
-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.describe.configure({ retries: 0 });
-
-  // Test vector DBs without LlamaParse
-  for (const vectorDb of vectorDbs) {
-    const optionDescription = `templateType: ${templateType}, vectorDb: ${vectorDb}, dataSource: ${dataSource}`;
-
-    test(`Vector DB test - ${optionDescription}`, async () => {
-      // skip vectordb test for llamaindexserver
-      test.skip(
-        templateType === "llamaindexserver",
-        "skipping vectorDB test for llamaindexserver",
-      );
-
-      await runTest({
-        templateType: templateType,
-        useLlamaParse: false, // Disable LlamaParse for vectorDB test
-        vectorDb: vectorDb,
-      });
-    });
-  }
-
-  // No vectorDB, with LlamaParse and useCase
-  // Only need to test use case with example data source
-  if (dataSource === "--example-file") {
-    for (const useCase of useCases) {
-      const optionDescription = `templateType: ${templateType}, useCase: ${useCase}`;
-      test.describe(`useCase test - ${optionDescription}`, () => {
-        test.skip(
-          templateType === "streaming",
-          "Skipping use case test for streaming template.",
-        );
-        test(`no llamaParse - ${optionDescription}`, async () => {
-          await runTest({
-            templateType: templateType,
-            useLlamaParse: false,
-            useCase: useCase,
-          });
-        });
-        // Skipping llamacloud for the use case doesn't use index.
-        if (useCase !== "code_generator" && useCase !== "document_generator") {
-          test(`llamaParse - ${optionDescription}`, async () => {
-            await runTest({
-              templateType: templateType,
-              useLlamaParse: true,
-              useCase: useCase,
-            });
-          });
-        }
-      });
-    }
-  }
-});
-
-async function runTest(options: {
-  templateType: TemplateType;
-  useLlamaParse: boolean;
-  useCase?: TemplateUseCase;
-  vectorDb?: TemplateVectorDB;
-}) {
-  const cwd = await createTestDir();
-
-  const result = await runCreateLlama({
-    cwd: cwd,
-    templateType: options.templateType,
-    templateFramework: templateFramework,
-    dataSource: dataSource,
-    vectorDb: options.vectorDb ?? "none",
-    port: 3000,
-    postInstallAction: "none",
-    templateUI: undefined,
-    appType: templateFramework === "nextjs" ? "" : "--no-frontend",
-    llamaCloudProjectName: undefined,
-    llamaCloudIndexName: undefined,
-    tools: undefined,
-    useLlamaParse: options.useLlamaParse,
-    useCase: options.useCase,
-  });
-  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 --ignore-workspace",
-      {
-        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;
-  }
-}

packages/create-llama/helpers/uv.ts

@@ -1,42 +0,0 @@
-// Migrate poetry to uv
-import { execSync } from "child_process";
-import fs from "fs";
-import { red } from "picocolors";
-
-export function isUvAvailable(): boolean {
-  try {
-    execSync("uv --version", { stdio: "ignore" });
-    return true;
-  } catch (_) {}
-  return false;
-}
-
-export function tryUvSync(): boolean {
-  try {
-    console.log("Syncing environment with pyproject.toml...");
-    execSync(`uv sync`, {
-      stdio: "inherit",
-    });
-    return true;
-  } catch (_) {}
-  return false;
-}
-
-export function tryUvRun(command: string): boolean {
-  try {
-    // Use uv run <command>
-    execSync(`uv run ${command}`, { stdio: "inherit" });
-    return true;
-  } catch (error) {
-    console.error(red(`Failed to run ${command}. Error: ${error}`));
-    return false;
-  }
-}
-
-export function isHavingUvLockFile(): boolean {
-  try {
-    // Check if uv.lock exists in the current directory
-    return fs.existsSync("uv.lock");
-  } catch (_) {}
-  return false;
-}

packages/create-llama/package.json

@@ -1,76 +0,0 @@
-{
-  "name": "create-llama",
-  "version": "0.5.20",
-  "description": "Create LlamaIndex-powered apps with one command",
-  "keywords": [
-    "rag",
-    "llamaindex",
-    "next.js"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/run-llama/create-llama",
-    "directory": "packages/create-llama"
-  },
-  "license": "MIT",
-  "bin": {
-    "create-llama": "./dist/index.js"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE.md"
-  ],
-  "scripts": {
-    "copy": "cp -r ../../README.md ../../LICENSE.md .",
-    "build": "bash ./scripts/build.sh",
-    "build:ncc": "pnpm run clean && ncc build ./index.ts -o ./dist/ --minify --no-cache --no-source-map-register",
-    "postbuild": "pnpm run copy",
-    "clean": "rimraf --glob ./dist ./templates/**/__pycache__ ./templates/**/node_modules ./templates/**/poetry.lock",
-    "dev": "ncc build ./index.ts -w -o dist/",
-    "e2e": "playwright test",
-    "e2e:python": "playwright test e2e/shared e2e/python",
-    "e2e:typescript": "playwright test e2e/shared e2e/typescript",
-    "pack-install": "bash ./scripts/pack.sh"
-  },
-  "dependencies": {
-    "@types/async-retry": "1.4.2",
-    "@types/ci-info": "2.0.0",
-    "@types/cross-spawn": "6.0.0",
-    "@types/fs-extra": "11.0.4",
-    "@types/node": "^20.11.7",
-    "@types/prompts": "2.4.2",
-    "@types/tar": "6.1.5",
-    "@types/validate-npm-package-name": "3.0.0",
-    "async-retry": "1.3.1",
-    "async-sema": "3.0.1",
-    "ci-info": "github:watson/ci-info#f43f6a1cefff47fb361c88cf4b943fdbcaafe540",
-    "commander": "12.1.0",
-    "cross-spawn": "7.0.3",
-    "fast-glob": "3.3.1",
-    "fs-extra": "11.2.0",
-    "global-agent": "^3.0.0",
-    "got": "10.7.0",
-    "ollama": "^0.5.0",
-    "ora": "^8.0.1",
-    "picocolors": "1.0.0",
-    "prompts": "2.4.2",
-    "smol-toml": "^1.1.4",
-    "tar": "6.1.15",
-    "terminal-link": "^3.0.0",
-    "update-check": "1.5.4",
-    "validate-npm-package-name": "3.0.0",
-    "yaml": "2.4.1"
-  },
-  "devDependencies": {
-    "@playwright/test": "^1.41.1",
-    "@vercel/ncc": "0.38.1",
-    "rimraf": "^5.0.5",
-    "typescript": "^5.3.3",
-    "wait-port": "^1.1.0"
-  },
-  "packageManager": "pnpm@9.0.5",
-  "engines": {
-    "node": ">=16.14.0"
-  }
-}

packages/create-llama/questions/simple.ts

@@ -1,193 +0,0 @@
-import prompts from "prompts";
-import { EXAMPLE_10K_SEC_FILES, EXAMPLE_FILE } from "../helpers/datasources";
-import { askModelConfig } from "../helpers/providers";
-import { getTools } from "../helpers/tools";
-import { ModelConfig, TemplateFramework } from "../helpers/types";
-import { PureQuestionArgs, QuestionResults } from "./types";
-import { askPostInstallAction, questionHandlers } from "./utils";
-
-type AppType =
-  | "agentic_rag"
-  | "financial_report"
-  | "deep_research"
-  | "code_generator"
-  | "document_generator";
-
-type SimpleAnswers = {
-  appType: AppType;
-  language: TemplateFramework;
-  useLlamaCloud: boolean;
-  llamaCloudKey?: string;
-};
-
-export const askSimpleQuestions = async (
-  args: PureQuestionArgs,
-): Promise<QuestionResults> => {
-  const { appType } = await prompts(
-    {
-      type: "select",
-      name: "appType",
-      message: "What use case do you want to build?",
-      choices: [
-        {
-          title: "Agentic RAG",
-          value: "agentic_rag",
-          description:
-            "Chatbot that answers questions based on provided documents.",
-        },
-        {
-          title: "Financial Report",
-          value: "financial_report",
-          description:
-            "Agent that analyzes data and generates visualizations by using a code interpreter.",
-        },
-        {
-          title: "Deep Research",
-          value: "deep_research",
-          description:
-            "Researches and analyzes provided documents from multiple perspectives, generating a comprehensive report with citations to support key findings and insights.",
-        },
-        {
-          title: "Code Generator",
-          value: "code_generator",
-          description: "Build a Vercel v0 styled code generator.",
-        },
-        {
-          title: "Document Generator",
-          value: "document_generator",
-          description: "Build a OpenAI canvas-styled document generator.",
-        },
-      ],
-    },
-    questionHandlers,
-  );
-
-  let language: TemplateFramework = "fastapi";
-  let llamaCloudKey = args.llamaCloudKey;
-
-  let useLlamaCloud = false;
-
-  const { language: newLanguage } = await prompts(
-    {
-      type: "select",
-      name: "language",
-      message: "What language do you want to use?",
-      choices: [
-        { title: "Python (FastAPI)", value: "fastapi" },
-        { title: "Typescript (NextJS)", value: "nextjs" },
-      ],
-    },
-    questionHandlers,
-  );
-  language = newLanguage;
-
-  if (appType !== "code_generator" && appType !== "document_generator") {
-    const { useLlamaCloud: newUseLlamaCloud } = await prompts(
-      {
-        type: "toggle",
-        name: "useLlamaCloud",
-        message: "Do you want to use LlamaCloud services?",
-        initial: false,
-        active: "Yes",
-        inactive: "No",
-        hint: "see https://www.llamaindex.ai/enterprise for more info",
-      },
-      questionHandlers,
-    );
-    useLlamaCloud = newUseLlamaCloud;
-  }
-
-  if (useLlamaCloud && !llamaCloudKey) {
-    // Ask for LlamaCloud API key, if not set
-    const { llamaCloudKey: newLlamaCloudKey } = await prompts(
-      {
-        type: "text",
-        name: "llamaCloudKey",
-        message:
-          "Please provide your LlamaCloud API key (leave blank to skip):",
-      },
-      questionHandlers,
-    );
-    llamaCloudKey = newLlamaCloudKey || process.env.LLAMA_CLOUD_API_KEY;
-  }
-
-  const results = await convertAnswers(args, {
-    appType,
-    language,
-    useLlamaCloud,
-    llamaCloudKey,
-  });
-
-  results.postInstallAction = await askPostInstallAction(results);
-  return results;
-};
-
-const convertAnswers = async (
-  args: PureQuestionArgs,
-  answers: SimpleAnswers,
-): Promise<QuestionResults> => {
-  const MODEL_GPT41: ModelConfig = {
-    provider: "openai",
-    apiKey: args.openAiKey,
-    model: "gpt-4.1",
-    embeddingModel: "text-embedding-3-large",
-    dimensions: 1536,
-    isConfigured(): boolean {
-      return !!args.openAiKey;
-    },
-  };
-  const lookup: Record<
-    AppType,
-    Pick<QuestionResults, "template" | "tools" | "dataSources" | "useCase"> & {
-      modelConfig?: ModelConfig;
-    }
-  > = {
-    agentic_rag: {
-      template: "llamaindexserver",
-      dataSources: [EXAMPLE_FILE],
-    },
-    financial_report: {
-      template: "llamaindexserver",
-      dataSources: EXAMPLE_10K_SEC_FILES,
-      tools: getTools(["interpreter", "document_generator"]),
-      modelConfig: MODEL_GPT41,
-    },
-    deep_research: {
-      template: "llamaindexserver",
-      dataSources: EXAMPLE_10K_SEC_FILES,
-      tools: [],
-      modelConfig: MODEL_GPT41,
-    },
-    code_generator: {
-      template: "llamaindexserver",
-      dataSources: [],
-      tools: [],
-      modelConfig: MODEL_GPT41,
-    },
-    document_generator: {
-      template: "llamaindexserver",
-      dataSources: [],
-      tools: [],
-      modelConfig: MODEL_GPT41,
-    },
-  };
-
-  const results = lookup[answers.appType];
-  return {
-    framework: answers.language,
-    useCase: answers.appType,
-    ui: "shadcn",
-    llamaCloudKey: answers.llamaCloudKey,
-    useLlamaParse: answers.useLlamaCloud,
-    vectorDb: answers.useLlamaCloud ? "llamacloud" : "none",
-    ...results,
-    modelConfig:
-      results.modelConfig ??
-      (await askModelConfig({
-        openAiKey: args.openAiKey,
-        askModels: args.askModels ?? false,
-        framework: answers.language,
-      })),
-    frontend: true,
-  };
-};