update paths for macos

.changeset/config.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://unpkg.com/@changesets/config@3.0.0/schema.json",
   "changelog": "@changesets/cli/changelog",
-  "commit": false,
+  "commit": true,
   "fixed": [],
   "linked": [],
   "access": "public",

.changeset/shaggy-ads-fix.md

@@ -0,0 +1,5 @@
+---
+"create-llama": patch
+---
+
+Add fetching llm and embedding models from server

.changeset/tasty-hairs-wait.md

@@ -0,0 +1,5 @@
+---
+"create-llama": patch
+---
+
+Add Milvus vector database

.coderabbit.yaml

@@ -1,6 +0,0 @@
-# coderabbit.yml
-reviews:
-  path_instructions:
-    - path: "templates/**"
-      instructions: |
-        For files under the `templates` folder, do not report 'Missing Dependencies Detected' errors.

.github/workflows/e2e.yml

@@ -1,149 +1,65 @@
-name: E2E Tests for create-llama package
+name: E2E Tests
 on:
   push:
     branches: [main]
-    paths-ignore:
-      - "python/llama-index-server/**"
   pull_request:
     branches: [main]
-    paths-ignore:
-      - "python/llama-index-server/**"
+
+env:
+  POETRY_VERSION: "1.6.1"
 
 jobs:
-  e2e-python:
-    name: python
+  e2e:
+    name: create-llama
     timeout-minutes: 60
     strategy:
       fail-fast: true
       matrix:
-        node-version: [20]
+        node-version: [18, 20]
         python-version: ["3.11"]
-        os: [macos-latest, windows-latest, ubuntu-22.04]
-        frameworks: ["fastapi"]
-        datasources: ["--no-files", "--example-file", "--llamacloud"]
+        os: [macos-latest, windows-latest]
     defaults:
       run:
         shell: bash
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
-
       - name: Set up python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v4
         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
-
-      - uses: pnpm/action-setup@v3
-
+      - name: Install Poetry
+        uses: snok/install-poetry@v1
+        with:
+          version: ${{ env.POETRY_VERSION }}
+      - uses: pnpm/action-setup@v2
       - name: Setup Node.js ${{ matrix.node-version }}
         uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
           cache: "pnpm"
-
       - name: Install dependencies
         run: pnpm install
-
       - 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
-
-      - name: Install
-        run: pnpm run pack-install
-        working-directory: packages/create-llama
-
-      - name: Run Playwright tests for Python
-        run: pnpm run e2e:python
+        working-directory: .
+      - name: Pack
+        run: pnpm pack --pack-destination ./output
+        working-directory: .
+      - name: Extract Pack
+        run: tar -xvzf ./output/*.tgz -C ./output
+        working-directory: .
+      - name: Run Playwright tests
+        run: pnpm exec playwright test
         env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          LLAMA_CLOUD_API_KEY: ${{ secrets.LLAMA_CLOUD_API_KEY }}
-          FRAMEWORK: ${{ matrix.frameworks }}
-          DATASOURCE: ${{ matrix.datasources }}
-          PYTHONIOENCODING: utf-8
-          PYTHONLEGACYWINDOWSSTDIO: utf-8
-        working-directory: packages/create-llama
-
-      - uses: actions/upload-artifact@v4
+        working-directory: .
+      - uses: actions/upload-artifact@v3
         if: always()
         with:
-          name: playwright-report-python-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.datasources }}
-          path: packages/create-llama/playwright-report/
-          overwrite: true
-          retention-days: 30
-
-  e2e-typescript:
-    name: typescript
-    timeout-minutes: 60
-    strategy:
-      fail-fast: true
-      matrix:
-        node-version: [20, 22]
-        python-version: ["3.11"]
-        os: [macos-latest, windows-latest, ubuntu-22.04]
-        frameworks: ["nextjs"]
-        datasources: ["--no-files", "--example-file", "--llamacloud"]
-    defaults:
-      run:
-        shell: bash
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Install 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
-
-      - uses: pnpm/action-setup@v3
-
-      - name: Setup Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-          cache: "pnpm"
-
-      - name: Install dependencies
-        run: pnpm install
-
-      - name: Install Playwright Browsers
-        run: pnpm exec playwright install --with-deps
-        working-directory: packages/create-llama
-
-      - name: Build create-llama
-        run: pnpm run build
-        working-directory: packages/create-llama
-
-      - name: Install
-        run: pnpm run pack-install
-        working-directory: packages/create-llama
-
-      - name: Run Playwright tests for TypeScript
-        run: pnpm run e2e:typescript
-        env:
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          LLAMA_CLOUD_API_KEY: ${{ secrets.LLAMA_CLOUD_API_KEY }}
-          FRAMEWORK: ${{ matrix.frameworks }}
-          DATASOURCE: ${{ matrix.datasources }}
-        working-directory: packages/create-llama
-
-      - uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: playwright-report-typescript-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.datasources }}-node${{ matrix.node-version }}
-          path: packages/create-llama/playwright-report/
-          overwrite: true
+          name: playwright-report
+          path: ./playwright-report/
           retention-days: 30

.github/workflows/lint_on_push_or_pull.yml

@@ -13,32 +13,17 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-
-      - uses: pnpm/action-setup@v3
-
+      - uses: pnpm/action-setup@v2
+        with:
+          version: latest
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
           node-version-file: ".nvmrc"
           cache: "pnpm"
-
       - name: Install dependencies
         run: pnpm install
-
       - name: Run lint
         run: pnpm run lint
-
       - name: Run Prettier
         run: pnpm run format
-
-      - 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/publish_github.yml

@@ -1,36 +0,0 @@
-name: Publish to GitHub Releases
-
-on:
-  push:
-    tags:
-      - "v*"
-
-jobs:
-  build-and-publish:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Repo
-        uses: actions/checkout@v4
-
-      - uses: pnpm/action-setup@v3
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: ".nvmrc"
-          cache: "pnpm"
-
-      - name: Install dependencies
-        run: pnpm install
-
-      - name: Build tarball
-        run: |
-          pnpm pack
-
-      - name: Create release
-        uses: ncipollo/release-action@v1
-        with:
-          artifacts: "create-llama-*.tgz"
-          name: Release ${{ github.ref }}
-          bodyFile: "CHANGELOG.md"
-          token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/release.yml

@@ -1,58 +0,0 @@
-name: Release
-
-on:
-  push:
-    branches:
-      - main
-
-concurrency: ${{ github.workflow }}-${{ github.ref }}
-
-jobs:
-  release:
-    name: Release
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Repo
-        uses: actions/checkout@v4
-
-      - uses: pnpm/action-setup@v3
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v3
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: ".nvmrc"
-          cache: "pnpm"
-
-      - name: Install dependencies
-        run: pnpm install
-
-      - name: Add auth token to .npmrc file
-        run: |
-          cat << EOF >> ".npmrc"
-            //registry.npmjs.org/:_authToken=$NPM_TOKEN
-          EOF
-        env:
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-      - name: Get changeset status
-        id: get-changeset-status
-        run: |
-          pnpm changeset status --output .changeset/status.json
-          new_version=$(jq -r '.releases[0].newVersion' < .changeset/status.json)
-          rm -v .changeset/status.json
-          echo "new-version=${new_version}" >> "$GITHUB_OUTPUT"
-
-      - name: Create Release Pull Request or Publish to npm
-        id: changesets
-        uses: changesets/action@v1
-        with:
-          commit: Release ${{ steps.get-changeset-status.outputs.new-version }}
-          title: Release ${{ steps.get-changeset-status.outputs.new-version }}
-          # build package and call changeset publish
-          publish: pnpm release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/release_llama_index_server.yml

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

.github/workflows/test_llama_index_server.yml

@@ -1,111 +0,0 @@
-name: Build Package
-
-on:
-  pull_request:
-
-env:
-  POETRY_VERSION: "1.8.3"
-  PYTHON_VERSION: "3.9"
-
-jobs:
-  unit-test:
-    name: Unit Tests
-    runs-on: ${{ matrix.os }}
-    defaults:
-      run:
-        working-directory: python/llama-index-server
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest]
-        python-version: ["3.9"]
-    steps:
-      - uses: actions/checkout@v4
-
-      - 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: Configure Poetry
-        run: |
-          poetry config virtualenvs.create true
-          poetry config virtualenvs.in-project true
-          poetry env use python
-
-      - name: Install dependencies
-        shell: bash
-        run: poetry install --with dev
-
-      - name: Run unit tests
-        shell: bash
-        run: |
-          poetry run pytest tests
-
-  type-check:
-    name: Type Check
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: python/llama-index-server
-    steps:
-      - uses: actions/checkout@v4
-
-      - 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: Configure Poetry
-        run: |
-          poetry config virtualenvs.create true
-          poetry config virtualenvs.in-project true
-          poetry env use python
-
-      - name: Install dependencies
-        shell: bash
-        run: poetry install --with dev
-
-      - name: Run mypy
-        shell: bash
-        run: poetry run mypy llama_index
-
-  build:
-    needs: [unit-test, type-check]
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: python/llama-index-server
-    steps:
-      - uses: actions/checkout@v4
-      - 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: Clear python cache
-        shell: bash
-        run: poetry cache clear --all pypi
-      - name: Build package
-        shell: bash
-        run: poetry build
-      - name: Test installing built package
-        shell: bash
-        run: python -m pip install .
-      - name: Test import
-        shell: bash
-        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: python/llama-index-server/dist/

.gitignore

@@ -6,6 +6,9 @@ node_modules
 .pnpm-store
 .pnp.js
 
+# testing
+coverage
+
 # next.js
 .next/
 out/
@@ -31,9 +34,14 @@ yarn-error.log*
 dist/
 lib/
 
+# e2e
+.cache
+test-results/
+playwright-report/
+blob-report/
+playwright/.cache/
+.tsbuildinfo
+e2e/cache
+
 # intellij
 **/.idea
-
-# vscode
-.vscode
-!.vscode/settings.json

.husky/pre-commit

@@ -1,3 +1,2 @@
 pnpm format
 pnpm lint
-uvx ruff format --check packages/create-llama/templates/

CHANGELOG.md

@@ -0,0 +1,183 @@
+# create-llama
+
+## 0.0.29
+
+### Patch Changes
+
+- edd24c2: Add observability with openllmetry
+- 403fc6f: Minor bug fixes to improve DX (missing .env value and updated error messages)
+- 0f79757: Ability to download community submodules
+
+## 0.0.28
+
+### Patch Changes
+
+- 89a49f4: Add more config variables to .env file
+- fdf48dd: Add "Start in VSCode" option to postInstallAction
+- fdf48dd: Add devcontainers to generated code
+
+## 0.0.27
+
+### Patch Changes
+
+- 2d29350: Add LlamaParse option when selecting a pdf file or a folder (FastAPI only)
+- b354f23: Add embedding model option to create-llama (FastAPI only)
+
+## 0.0.26
+
+### Patch Changes
+
+- 09d532e: feat: generate llama pack project from llama index
+- cfdd6db: feat: add pinecone support to create llama
+- ef25d69: upgrade llama-index package to version v0.10.7 for create-llama app
+- 50dfd7b: update fastapi for CVE-2024-24762
+
+## 0.0.25
+
+### Patch Changes
+
+- d06a85b: Add option to create an agent by selecting tools (Google, Wikipedia)
+- 7b7329b: Added latest turbo models for GPT-3.5 and GPT 4
+
+## 0.0.24
+
+### Patch Changes
+
+- ba95ca3: Use condense plus context chat engine for FastAPI as default
+
+## 0.0.23
+
+### Patch Changes
+
+- c680af6: Fixed issues with locating templates path
+
+## 0.0.22
+
+### Patch Changes
+
+- 6dd401e: Add an option to provide an URL and chat with the website data (FastAPI only)
+- e9b87ef: Select a folder as data source and support more file types (.pdf, .doc, .docx, .xls, .xlsx, .csv)
+
+## 0.0.20
+
+### Patch Changes
+
+- 27d55fd: Add an option to provide an URL and chat with the website data
+
+## 0.0.19
+
+### Patch Changes
+
+- 3a29a80: Add node_modules to gitignore in Express backends
+- fe03aaa: feat: generate llama pack example
+
+## 0.0.18
+
+### Patch Changes
+
+- 88d3b41: fix packaging
+
+## 0.0.17
+
+### Patch Changes
+
+- fa17f7e: Add an option that allows the user to run the generated app
+- 9e5d8e1: Add an option to select a local PDF file as data source
+
+## 0.0.16
+
+### Patch Changes
+
+- a73942d: Fix: Bundle mongo dependency with NextJS
+- 9492cc6: Feat: Added option to automatically install dependencies (for Python and TS)
+- f74dea5: Feat: Show images in chat messages using GPT4 Vision (Express and NextJS only)
+
+## 0.0.15
+
+### Patch Changes
+
+- 8e124e5: feat: support showing image on chat message
+
+## 0.0.14
+
+### Patch Changes
+
+- 2e6b36e: fix: re-organize file structure
+- 2b356c8: fix: relative path incorrect
+
+## 0.0.13
+
+### Patch Changes
+
+- Added PostgreSQL vector store (for Typescript and Python)
+- Improved async handling in FastAPI
+
+## 0.0.12
+
+### Patch Changes
+
+- 9c5e22a: Added cross-env so frontends with Express/FastAPI backends are working under Windows
+- 5ab65eb: Bring Python templates with TS templates to feature parity
+- 9c5e22a: Added vector DB selector to create-llama (starting with MongoDB support)
+
+## 0.0.11
+
+### Patch Changes
+
+- 2aeb341: - Added option to create a new project based on community templates
+  - Added OpenAI model selector for NextJS projects
+  - Added GPT4 Vision support (and file upload)
+
+## 0.0.10
+
+### Patch Changes
+
+- Bugfixes (thanks @marcusschiesser)
+
+## 0.0.9
+
+### Patch Changes
+
+- acfe232: Deployment fixes (thanks @seldo)
+
+## 0.0.8
+
+### Patch Changes
+
+- 8cdb07f: Fix Next deployment (thanks @seldo and @marcusschiesser)
+
+## 0.0.7
+
+### Patch Changes
+
+- 9f9f293: Added more to README and made it easier to switch models (thanks @seldo)
+
+## 0.0.6
+
+### Patch Changes
+
+- 4431ec7: Label bug fix (thanks @marcusschiesser)
+
+## 0.0.5
+
+### Patch Changes
+
+- 25257f4: Fix issue where it doesn't find OpenAI Key when running npm run generate (#182) (thanks @RayFernando1337)
+
+## 0.0.4
+
+### Patch Changes
+
+- 031e926: Update create-llama readme (thanks @logan-markewich)
+
+## 0.0.3
+
+### Patch Changes
+
+- 91b42a3: change version (thanks @marcusschiesser)
+
+## 0.0.2
+
+### Patch Changes
+
+- e2a6805: Hello Create Llama (thanks @marcusschiesser)

CONTRIBUTING.md

@@ -1,73 +0,0 @@
-# Contributing
-
-## Getting Started
-
-Install NodeJS. Preferably v18 using nvm or n.
-
-Inside the `create-llama` directory:
-
-```
-npm i -g pnpm
-pnpm install
-```
-
-Note: we use pnpm in this repo, which has a lot of the same functionality and CLI options as npm but it does do some things better, like caching.
-
-### Building
-
-When we publish to NPM we will have a [ncc](https://github.com/vercel/ncc) compiled version of the tool. To run the build command, run
-
-```
-pnpm run build
-```
-
-### Test cases
-
-We are using a set of e2e tests to ensure that the tool works as expected.
-
-We're using [playwright](https://playwright.dev/) to run the tests.
-To install it, call:
-
-```
-pnpm exec playwright install --with-deps
-```
-
-Then you can create a global `create-llama` command (used by the e2e tests) that is linked to your local dev environment (if you update the build, you don't need to re-link):
-
-```
-pnpm link --global
-```
-
-And then finally run the tests:
-
-```
-pnpm run e2e
-```
-
-To write new test cases write them in [e2e](/e2e)
-
-## Changeset
-
-We use [changesets](https://github.com/changesets/changesets) for managing versions and changelogs. To create a new changeset, run:
-
-```
-pnpm changeset
-```
-
-Please send a descriptive changeset for each PR.
-
-## Publishing (maintainers only)
-
-To publish a new version of the library, first create a new version:
-
-```shell
-pnpm new-version
-```
-
-If everything looks good, commit the generated files and release the new version:
-
-```shell
-pnpm release
-git push # push to the main branch
-git push --tags
-```

README.md

@@ -1,20 +1,14 @@
-# Create Llama
+# Create LlamaIndex App
 
 The easiest way to get started with [LlamaIndex](https://www.llamaindex.ai/) is by using `create-llama`. This CLI tool enables you to quickly start building a new LlamaIndex application, with everything set up for you.
 
-## Get started
-
 Just run
 
 ```bash
 npx create-llama@latest
 ```
 
-to get started, or watch this video for a demo session:
-
-<img src="https://github.com/user-attachments/assets/c4a7fe18-8e30-498a-96f8-78127dd706b9" width="100%">
-
-Once your app is generated, run
+to get started, or see below for more options. Once your app is generated, run
 
 ```bash
 npm run dev
@@ -24,25 +18,27 @@ to start the development server. You can then visit [http://localhost:3000](http
 
 ## What you'll get
 
-- A set of pre-configured use cases to get you started, e.g. Agentic RAG, Data Analysis, Report Generation, etc.
-- A Next.js-powered front-end using components from [shadcn/ui](https://ui.shadcn.com/). The app is set up as a chat interface that can answer questions about your data or interact with your agent
-- Your choice of two back-ends:
-  - **Next.js**: if you select this option, you’ll have a full-stack Next.js application that you can deploy to a host like [Vercel](https://vercel.com/) in just a few clicks. This uses [LlamaIndex.TS](https://www.npmjs.com/package/llamaindex), our TypeScript library.
-  - **Python FastAPI**: if you select this option, you’ll get a separate backend powered by the [llama-index Python package](https://pypi.org/project/llama-index/), which you can deploy to a service like [Render](https://render.com/) or [fly.io](https://fly.io/). The separate Next.js front-end will connect to this backend.
-- Each back-end has two endpoints:
-  - One streaming chat endpoint, that allow you to send the state of your chat and receive additional responses
-  - One endpoint to upload private files which can be used in your chat
+- A Next.js-powered front-end. The app is set up as a chat interface that can answer questions about your data (see below)
+  - You can style it with HTML and CSS, or you can optionally use components from [shadcn/ui](https://ui.shadcn.com/)
+- Your choice of 3 back-ends:
+  - **Next.js**: if you select this option, you’ll have a full stack Next.js application that you can deploy to a host like [Vercel](https://vercel.com/) in just a few clicks. This uses [LlamaIndex.TS](https://www.npmjs.com/package/llamaindex), our TypeScript library.
+  - **Express**: if you want a more traditional Node.js application you can generate an Express backend. This also uses LlamaIndex.TS.
+  - **Python FastAPI**: if you select this option you’ll get a backend powered by the [llama-index python package](https://pypi.org/project/llama-index/), which you can deploy to a service like Render or fly.io.
+- The back-end has a single endpoint that allows you to send the state of your chat and receive additional responses
+- You can choose whether you want a streaming or non-streaming back-end (if you're not sure, we recommend streaming)
+- You can choose whether you want to use `ContextChatEngine` or `SimpleChatEngine`
+  - `SimpleChatEngine` will just talk to the LLM directly without using your data
+  - `ContextChatEngine` will use your data to answer questions (see below).
 - The app uses OpenAI by default, so you'll need an OpenAI API key, or you can customize it to use any of the dozens of LLMs we support.
 
-Here's how it looks like:
-
-https://github.com/user-attachments/assets/d57af1a1-d99b-4e9c-98d9-4cbd1327eff8
-
 ## Using your data
 
-Optionally, you can supply your own data; the app will index it and make use of it, e.g. to answer questions. Your generated app will have a folder called `data` (If you're using Express or Python and generate a frontend, it will be `./backend/data`).
+If you've enabled `ContextChatEngine`, you can supply your own data and the app will index it and answer questions. Your generated app will have a folder called `data`:
 
-The app will ingest any supported files you put in this directory. Your Next.js and Express apps use LlamaIndex.TS, so they will be able to ingest any PDF, text, CSV, Markdown, Word and HTML files. The Python backend can read even more types, including video and audio files.
+- With the Next.js backend this is `./data`
+- With the Express or Python backend this is in `./backend/data`
+
+The app will ingest any supported files you put in this directory. Your Next.js and Express apps use LlamaIndex.TS so they will be able to ingest any PDF, text, CSV, Markdown, Word and HTML files. The Python backend can read even more types, including video and audio files.
 
 Before you can use your data, you need to index it. If you're using the Next.js or Express apps, run:
 
@@ -50,24 +46,22 @@ Before you can use your data, you need to index it. If you're using the Next.js
 npm run generate
 ```
 
-Then re-start your app. Remember you'll need to re-run `generate` if you add new files to your `data` folder.
+Then re-start your app. Remember you'll need to re-run `generate` if you add new files to your `data` folder. If you're using the Python backend, you can trigger indexing of your data by deleting the `./storage` folder and re-starting the app.
 
-If you're using the Python backend, you can trigger indexing of your data by calling:
+## Don't want a front-end?
 
-```bash
-uv run generate
-```
+It's optional! If you've selected the Python or Express back-ends, just delete the `frontend` folder and you'll get an API without any front-end code.
 
-## Customizing the AI models
+## Customizing the LLM
 
-The app will default to OpenAI's `gpt-4o-mini` LLM and `text-embedding-3-large` embedding model.
+By default the app will use OpenAI's gpt-3.5-turbo model. If you want to use GPT-4, you can modify this by editing a file:
 
-If you want to use different OpenAI models, add the `--ask-models` CLI parameter.
+- In the Next.js backend, edit `./app/api/chat/route.ts` and replace `gpt-3.5-turbo` with `gpt-4`
+- In the Express backend, edit `./backend/src/controllers/chat.controller.ts` and likewise replace `gpt-3.5-turbo` with `gpt-4`
+- In the Python backend, edit `./backend/app/utils/index.py` and once again replace `gpt-3.5-turbo` with `gpt-4`
 
 You can also replace OpenAI with one of our [dozens of other supported LLMs](https://docs.llamaindex.ai/en/stable/module_guides/models/llms/modules.html).
 
-To do so, you have to manually change the generated code (edit the `settings.ts` file for Typescript projects or the `settings.py` file for Python projects)
-
 ## Example
 
 The simplest thing to do is run `create-llama` in interactive mode:
@@ -90,51 +84,43 @@ Need to install the following packages:
   create-llama@latest
 Ok to proceed? (y) y
 ✔ What is your project named? … my-app
-✔ What app do you want to build? › Agentic RAG
-✔ What language do you want to use? › Python (FastAPI)
-✔ Do you want to use LlamaCloud services? … No / Yes
-✔ Please provide your LlamaCloud API key (leave blank to skip): …
+✔ Which template would you like to use? › Chat with streaming
+✔ Which framework would you like to use? › NextJS
+✔ Which UI would you like to use? › Just HTML
+✔ Which chat engine would you like to use? › ContextChatEngine
 ✔ Please provide your OpenAI API key (leave blank to skip): …
-? How would you like to proceed? › - Use arrow-keys. Return to submit.
-    Just generate code (~1 sec)
-❯   Start in VSCode (~1 sec)
-    Generate code and install dependencies (~2 min)
+✔ Would you like to use ESLint? … No / Yes
+Creating a new LlamaIndex app in /home/my-app.
 ```
 
 ### Running non-interactively
 
 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`.
+non-interactively. See `create-llama --help`:
 
-### Running in pro mode
+```bash
+create-llama <project-directory> [options]
 
-If you prefer more advanced customization options, you can run `create-llama` in pro mode using the `--pro` flag.
+Options:
+  -V, --version                      output the version number
 
-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:
+  --use-npm
 
-- **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.
+    Explicitly tell the CLI to bootstrap the app using npm
 
-Pro mode is ideal for developers who want fine-grained control over their project's configuration and are comfortable with more technical setup options.
+  --use-pnpm
+
+    Explicitly tell the CLI to bootstrap the app using pnpm
+
+  --use-yarn
+
+    Explicitly tell the CLI to bootstrap the app using Yarn
+
+```
 
 ## 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

@@ -7,16 +7,17 @@ import { getOnline } from "./helpers/is-online";
 import { isWriteable } from "./helpers/is-writeable";
 import { makeDir } from "./helpers/make-dir";
 
+import fs from "fs";
 import terminalLink from "terminal-link";
-import type { InstallTemplateArgs, TemplateObservability } from "./helpers";
+import type { InstallTemplateArgs } from "./helpers";
 import { installTemplate } from "./helpers";
+import { writeDevcontainer } from "./helpers/devcontainer";
 import { templatesDir } from "./helpers/dir";
 import { toolsRequireConfig } from "./helpers/tools";
-import { configVSCode } from "./helpers/vscode";
 
 export type InstallAppArgs = Omit<
   InstallTemplateArgs,
-  "appName" | "root" | "isOnline" | "port"
+  "appName" | "root" | "isOnline" | "customApiPath"
 > & {
   appPath: string;
   frontend: boolean;
@@ -25,21 +26,24 @@ export type InstallAppArgs = Omit<
 export async function createApp({
   template,
   framework,
+  engine,
   ui,
   appPath,
   packageManager,
+  eslint,
   frontend,
-  modelConfig,
+  openAiKey,
   llamaCloudKey,
+  model,
+  embeddingModel,
   communityProjectConfig,
   llamapack,
   vectorDb,
+  externalPort,
   postInstallAction,
   dataSources,
   tools,
-  useLlamaParse,
   observability,
-  useCase,
 }: InstallAppArgs): Promise<void> {
   const root = path.resolve(appPath);
 
@@ -71,38 +75,50 @@ export async function createApp({
     root,
     template,
     framework,
+    engine,
     ui,
     packageManager,
     isOnline,
-    modelConfig,
+    eslint,
+    openAiKey,
     llamaCloudKey,
+    model,
+    embeddingModel,
     communityProjectConfig,
     llamapack,
     vectorDb,
+    externalPort,
     postInstallAction,
     dataSources,
     tools,
-    useLlamaParse,
     observability,
-    useCase,
   };
 
-  // Install backend
-  await installTemplate({ ...args, backend: true });
-
-  if (frontend && framework === "fastapi" && template !== "llamaindexserver") {
+  if (frontend) {
+    // install backend
+    const backendRoot = path.join(root, "backend");
+    await makeDir(backendRoot);
+    await installTemplate({ ...args, root: backendRoot, backend: true });
     // install frontend
-    const frontendRoot = path.join(root, ".frontend");
+    const frontendRoot = path.join(root, "frontend");
     await makeDir(frontendRoot);
     await installTemplate({
       ...args,
       root: frontendRoot,
       framework: "nextjs",
+      customApiPath: `http://localhost:${externalPort ?? 8000}/api/chat`,
       backend: false,
     });
+    // copy readme for fullstack
+    await fs.promises.copyFile(
+      path.join(templatesDir, "README-fullstack.md"),
+      path.join(root, "README.md"),
+    );
+  } else {
+    await installTemplate({ ...args, backend: true });
   }
 
-  await configVSCode(root, templatesDir, framework);
+  await writeDevcontainer(root, templatesDir, framework, frontend);
 
   process.chdir(root);
   if (tryGitInit(root)) {
@@ -110,14 +126,12 @@ export async function createApp({
     console.log();
   }
 
-  if (toolsRequireConfig(tools) && template !== "llamaindexserver") {
-    const configFile =
-      framework === "fastapi" ? "config/tools.yaml" : "config/tools.json";
+  if (toolsRequireConfig(tools)) {
     console.log(
       yellow(
         `You have selected tools that require configuration. Please configure them in the ${terminalLink(
-          configFile,
-          `file://${root}/${configFile}`,
+          "tools_config.json",
+          `file://${root}/tools_config.json`,
         )} file.`,
       ),
     );
@@ -132,42 +146,14 @@ export async function createApp({
     )} and learn how to get started.`,
   );
 
-  outputObservability(args.observability);
-
-  if (
-    dataSources.some((dataSource) => dataSource.type === "file") &&
-    process.platform === "linux"
-  ) {
+  if (args.observability === "opentelemetry") {
     console.log(
-      yellow(
-        `You can add your own data files to ${terminalLink(
-          "data",
-          `file://${root}/data`,
-        )} folder manually.`,
-      ),
+      `\n${yellow("Observability")}: Visit the ${terminalLink(
+        "documentation",
+        "https://traceloop.com/docs/openllmetry/integrations",
+      )} to set up the environment variables and start seeing execution traces.`,
     );
   }
 
   console.log();
 }
-
-function outputObservability(observability?: TemplateObservability) {
-  switch (observability) {
-    case "traceloop":
-      console.log(
-        `\n${yellow("Observability")}: Visit the ${terminalLink(
-          "documentation",
-          "https://traceloop.com/docs/openllmetry/integrations",
-        )} to set up the environment variables and start seeing execution traces.`,
-      );
-      break;
-    case "llamatrace":
-      console.log(
-        `\n${yellow("Observability")}: LlamaTrace has been configured for your project. Visit the ${terminalLink(
-          "LlamaTrace dashboard",
-          "https://llamatrace.com/login",
-        )} to view your traces and monitor your application.`,
-      );
-      break;
-  }
-}

e2e/basic.spec.ts

@@ -0,0 +1,145 @@
+/* eslint-disable turbo/no-undeclared-env-vars */
+import { expect, test } from "@playwright/test";
+import { ChildProcess } from "child_process";
+import fs from "fs";
+import path from "path";
+import type {
+  TemplateEngine,
+  TemplateFramework,
+  TemplatePostInstallAction,
+  TemplateType,
+  TemplateUI,
+} from "../helpers";
+import { createTestDir, runCreateLlama, type AppType } from "./utils";
+
+const templateTypes: TemplateType[] = ["streaming", "simple"];
+const templateFrameworks: TemplateFramework[] = [
+  "nextjs",
+  "express",
+  "fastapi",
+];
+const templateEngines: TemplateEngine[] = ["simple", "context"];
+const templateUIs: TemplateUI[] = ["shadcn", "html"];
+const templatePostInstallActions: TemplatePostInstallAction[] = [
+  "none",
+  "runApp",
+];
+
+for (const templateType of templateTypes) {
+  for (const templateFramework of templateFrameworks) {
+    for (const templateEngine of templateEngines) {
+      for (const templateUI of templateUIs) {
+        for (const templatePostInstallAction of templatePostInstallActions) {
+          if (templateFramework === "nextjs" && templateType === "simple") {
+            // nextjs doesn't support simple templates - skip tests
+            continue;
+          }
+          const appType: AppType =
+            templateFramework === "express" || templateFramework === "fastapi"
+              ? templateType === "simple"
+                ? "--no-frontend" // simple templates don't have frontends
+                : "--frontend"
+              : "";
+          if (appType === "--no-frontend" && templateUI !== "html") {
+            // if there's no frontend, don't iterate over UIs
+            continue;
+          }
+          test.describe(`try create-llama ${templateType} ${templateFramework} ${templateEngine} ${templateUI} ${appType} ${templatePostInstallAction}`, async () => {
+            let port: number;
+            let externalPort: number;
+            let cwd: string;
+            let name: string;
+            let appProcess: ChildProcess;
+            // Only test without using vector db for now
+            const vectorDb = "none";
+
+            test.beforeAll(async () => {
+              port = Math.floor(Math.random() * 10000) + 10000;
+              externalPort = port + 1;
+              cwd = await createTestDir();
+              const result = await runCreateLlama(
+                cwd,
+                templateType,
+                templateFramework,
+                templateEngine,
+                templateUI,
+                vectorDb,
+                appType,
+                port,
+                externalPort,
+                templatePostInstallAction,
+              );
+              name = result.projectName;
+              appProcess = result.appProcess;
+            });
+
+            test("App folder should exist", async () => {
+              const dirExists = fs.existsSync(path.join(cwd, name));
+              expect(dirExists).toBeTruthy();
+            });
+            test("Frontend should have a title", async ({ page }) => {
+              test.skip(templatePostInstallAction !== "runApp");
+              test.skip(appType === "--no-frontend");
+              await page.goto(`http://localhost:${port}`);
+              await expect(page.getByText("Built by LlamaIndex")).toBeVisible();
+            });
+
+            test("Frontend should be able to submit a message and receive a response", async ({
+              page,
+            }) => {
+              test.skip(templatePostInstallAction !== "runApp");
+              test.skip(appType === "--no-frontend");
+              await page.goto(`http://localhost:${port}`);
+              await page.fill("form input", "hello");
+              const [response] = await Promise.all([
+                page.waitForResponse(
+                  (res) => {
+                    return (
+                      res.url().includes("/api/chat") && res.status() === 200
+                    );
+                  },
+                  {
+                    timeout: 1000 * 60,
+                  },
+                ),
+                page.click("form button[type=submit]"),
+              ]);
+              const text = await response.text();
+              console.log("AI response when submitting message: ", text);
+              expect(response.ok()).toBeTruthy();
+            });
+
+            test("Backend should response when calling API", async ({
+              request,
+            }) => {
+              test.skip(templatePostInstallAction !== "runApp");
+              test.skip(appType !== "--no-frontend");
+              const backendPort = appType === "" ? port : externalPort;
+              const response = await request.post(
+                `http://localhost:${backendPort}/api/chat`,
+                {
+                  data: {
+                    messages: [
+                      {
+                        role: "user",
+                        content: "Hello",
+                      },
+                    ],
+                  },
+                },
+              );
+              const text = await response.text();
+              console.log("AI response when calling API: ", text);
+              expect(response.ok()).toBeTruthy();
+            });
+
+            // clean processes
+            test.afterAll(async () => {
+              appProcess?.kill();
+            });
+          });
+        }
+      }
+    }
+  }
+}

e2e/utils.ts

@@ -0,0 +1,183 @@
+import { ChildProcess, exec } from "child_process";
+import crypto from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import * as path from "path";
+import waitPort from "wait-port";
+import {
+  TemplateEngine,
+  TemplateFramework,
+  TemplatePostInstallAction,
+  TemplateType,
+  TemplateUI,
+  TemplateVectorDB,
+} from "../helpers";
+
+export type AppType = "--frontend" | "--no-frontend" | "";
+const MODEL = "gpt-3.5-turbo";
+const EMBEDDING_MODEL = "text-embedding-ada-002";
+export type CreateLlamaResult = {
+  projectName: string;
+  appProcess: ChildProcess;
+};
+
+// eslint-disable-next-line max-params
+export async function checkAppHasStarted(
+  frontend: boolean,
+  framework: TemplateFramework,
+  port: number,
+  externalPort: number,
+  timeout: number,
+) {
+  if (frontend) {
+    await Promise.all([
+      waitPort({
+        host: "localhost",
+        port: port,
+        timeout,
+      }),
+      waitPort({
+        host: "localhost",
+        port: externalPort,
+        timeout,
+      }),
+    ]).catch((err) => {
+      console.error(err);
+      throw err;
+    });
+  } else {
+    let wPort: number;
+    if (framework === "nextjs") {
+      wPort = port;
+    } else {
+      wPort = externalPort;
+    }
+    await waitPort({
+      host: "localhost",
+      port: wPort,
+      timeout,
+    }).catch((err) => {
+      console.error(err);
+      throw err;
+    });
+  }
+}
+
+// eslint-disable-next-line max-params
+export async function runCreateLlama(
+  cwd: string,
+  templateType: TemplateType,
+  templateFramework: TemplateFramework,
+  templateEngine: TemplateEngine,
+  templateUI: TemplateUI,
+  vectorDb: TemplateVectorDB,
+  appType: AppType,
+  port: number,
+  externalPort: number,
+  postInstallAction: TemplatePostInstallAction,
+): Promise<CreateLlamaResult> {
+  const createLlama = path.join(
+    __dirname,
+    "..",
+    "output",
+    "package",
+    "dist",
+    "index.js",
+  );
+
+  const name = [
+    templateType,
+    templateFramework,
+    templateEngine,
+    templateUI,
+    appType,
+  ].join("-");
+  const command = [
+    "node",
+    createLlama,
+    name,
+    "--template",
+    templateType,
+    "--framework",
+    templateFramework,
+    "--engine",
+    templateEngine,
+    "--ui",
+    templateUI,
+    "--vector-db",
+    vectorDb,
+    "--model",
+    MODEL,
+    "--embedding-model",
+    EMBEDDING_MODEL,
+    "--open-ai-key",
+    process.env.OPENAI_API_KEY || "testKey",
+    appType,
+    "--eslint",
+    "--use-npm",
+    "--port",
+    port,
+    "--external-port",
+    externalPort,
+    "--post-install-action",
+    postInstallAction,
+    "--tools",
+    "none",
+    "--no-llama-parse",
+    "--observability",
+    "none",
+  ].join(" ");
+  console.log(`running command '${command}' in ${cwd}`);
+  const appProcess = exec(command, {
+    cwd,
+    env: {
+      ...process.env,
+    },
+  });
+  appProcess.stderr?.on("data", (data) => {
+    console.log(data.toString());
+  });
+  appProcess.on("exit", (code) => {
+    if (code !== 0 && code !== null) {
+      throw new Error(`create-llama command was failed!`);
+    }
+  });
+
+  // Wait for app to start
+  if (postInstallAction === "runApp") {
+    await checkAppHasStarted(
+      appType === "--frontend",
+      templateFramework,
+      port,
+      externalPort,
+      1000 * 60 * 5,
+    );
+  } else {
+    // wait create-llama to exit
+    // we don't test install dependencies for now, so just set timeout for 10 seconds
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("create-llama timeout error"));
+      }, 1000 * 10);
+      appProcess.on("exit", (code) => {
+        if (code !== 0 && code !== null) {
+          clearTimeout(timeout);
+          reject(new Error("create-llama command was failed!"));
+        } else {
+          clearTimeout(timeout);
+          resolve(undefined);
+        }
+      });
+    });
+  }
+
+  return {
+    projectName: name,
+    appProcess,
+  };
+}
+
+export async function createTestDir() {
+  const cwd = path.join(__dirname, "cache", crypto.randomUUID());
+  await mkdir(cwd, { recursive: true });
+  return cwd;
+}

helpers/copy.ts

@@ -48,24 +48,3 @@ export const copy = async (
     }),
   );
 };
-
-export const assetRelocator = (name: string) => {
-  switch (name) {
-    case "gitignore":
-    case "npmrc":
-    case "eslintrc.json": {
-      return `.${name}`;
-    }
-    // README.md is ignored by webpack-asset-relocator-loader used by ncc:
-    // https://github.com/vercel/webpack-asset-relocator-loader/blob/e9308683d47ff507253e37c9bcbb99474603192b/src/asset-relocator.js#L227
-    case "README-template.md": {
-      return "README.md";
-    }
-    case "vscode_settings.json": {
-      return "settings.json";
-    }
-    default: {
-      return name;
-    }
-  }
-};

helpers/devcontainer.ts

@@ -0,0 +1,61 @@
+import fs from "fs";
+import path from "path";
+import { TemplateFramework } from "./types";
+
+function renderDevcontainerContent(
+  templatesDir: string,
+  framework: TemplateFramework,
+  frontend: boolean,
+) {
+  const devcontainerJson: any = JSON.parse(
+    fs.readFileSync(path.join(templatesDir, "devcontainer.json"), "utf8"),
+  );
+
+  // Modify postCreateCommand
+  if (frontend) {
+    devcontainerJson.postCreateCommand =
+      framework === "fastapi"
+        ? "cd backend && poetry install && cd ../frontend && npm install"
+        : "cd backend && npm install && cd ../frontend && npm install";
+  } else {
+    devcontainerJson.postCreateCommand =
+      framework === "fastapi" ? "poetry install" : "npm install";
+  }
+
+  // Modify containerEnv
+  if (framework === "fastapi") {
+    if (frontend) {
+      devcontainerJson.containerEnv = {
+        ...devcontainerJson.containerEnv,
+        PYTHONPATH: "${PYTHONPATH}:${workspaceFolder}/backend",
+      };
+    } else {
+      devcontainerJson.containerEnv = {
+        ...devcontainerJson.containerEnv,
+        PYTHONPATH: "${PYTHONPATH}:${workspaceFolder}",
+      };
+    }
+  }
+
+  return JSON.stringify(devcontainerJson, null, 2);
+}
+
+export const writeDevcontainer = async (
+  root: string,
+  templatesDir: string,
+  framework: TemplateFramework,
+  frontend: boolean,
+) => {
+  console.log("Adding .devcontainer");
+  const devcontainerContent = renderDevcontainerContent(
+    templatesDir,
+    framework,
+    frontend,
+  );
+  const devcontainerDir = path.join(root, ".devcontainer");
+  fs.mkdirSync(devcontainerDir);
+  await fs.promises.writeFile(
+    path.join(devcontainerDir, "devcontainer.json"),
+    devcontainerContent,
+  );
+};

helpers/env-variables.ts

@@ -0,0 +1,274 @@
+import fs from "fs/promises";
+import path from "path";
+import {
+  FileSourceConfig,
+  TemplateDataSource,
+  TemplateFramework,
+  TemplateVectorDB,
+  WebSourceConfig,
+} from "./types";
+
+type EnvVar = {
+  name?: string;
+  description?: string;
+  value?: string;
+};
+
+const renderEnvVar = (envVars: EnvVar[]): string => {
+  return envVars.reduce(
+    (prev, env) =>
+      prev +
+      (env.description
+        ? `# ${env.description.replaceAll("\n", "\n# ")}\n`
+        : "") +
+      (env.name
+        ? env.value
+          ? `${env.name}=${env.value}\n\n`
+          : `# ${env.name}=\n\n`
+        : ""),
+    "",
+  );
+};
+
+const getVectorDBEnvs = (vectorDb: TemplateVectorDB) => {
+  switch (vectorDb) {
+    case "mongo":
+      return [
+        {
+          name: "MONGO_URI",
+          description:
+            "For generating a connection URI, see https://docs.timescale.com/use-timescale/latest/services/create-a-service\nThe MongoDB connection URI.",
+        },
+        {
+          name: "MONGODB_DATABASE",
+        },
+        {
+          name: "MONGODB_VECTORS",
+        },
+        {
+          name: "MONGODB_VECTOR_INDEX",
+        },
+      ];
+    case "pg":
+      return [
+        {
+          name: "PG_CONNECTION_STRING",
+          description:
+            "For generating a connection URI, see https://docs.timescale.com/use-timescale/latest/services/create-a-service\nThe PostgreSQL connection string.",
+        },
+      ];
+
+    case "pinecone":
+      return [
+        {
+          name: "PINECONE_API_KEY",
+          description:
+            "Configuration for Pinecone vector store\nThe Pinecone API key.",
+        },
+        {
+          name: "PINECONE_ENVIRONMENT",
+        },
+        {
+          name: "PINECONE_INDEX_NAME",
+        },
+      ];
+    case "milvus":
+      return [
+        {
+          name: "MILVUS_ADDRESS",
+          description:
+            "The address of the Milvus server. Eg: http://localhost:19530",
+          value: "http://localhost:19530",
+        },
+        {
+          name: "MILVUS_COLLECTION",
+          description:
+            "The name of the Milvus collection to store the vectors.",
+          value: "llamacollection",
+        },
+        {
+          name: "MILVUS_USERNAME",
+          description: "The username to access the Milvus server.",
+        },
+        {
+          name: "MILVUS_PASSWORD",
+          description: "The password to access the Milvus server.",
+        },
+      ];
+    default:
+      return [];
+  }
+};
+
+const getDataSourceEnvs = (dataSources: TemplateDataSource[]) => {
+  const envs = [];
+  for (const source of dataSources) {
+    switch (source.type) {
+      case "web":
+        const config = source.config as WebSourceConfig;
+        envs.push(
+          {
+            name: "BASE_URL",
+            description: "The base URL to start web scraping.",
+            value: config.baseUrl,
+          },
+          {
+            name: "URL_PREFIX",
+            description: "The prefix of the URL to start web scraping.",
+            value: config.baseUrl,
+          },
+          {
+            name: "MAX_DEPTH",
+            description: "The maximum depth to scrape.",
+            value: config.depth?.toString(),
+          },
+        );
+    }
+  }
+  return envs;
+};
+
+export const createBackendEnvFile = async (
+  root: string,
+  opts: {
+    openAiKey?: string;
+    llamaCloudKey?: string;
+    vectorDb?: TemplateVectorDB;
+    model?: string;
+    embeddingModel?: string;
+    framework?: TemplateFramework;
+    dataSources?: TemplateDataSource[];
+    port?: number;
+  },
+) => {
+  // Init env values
+  const envFileName = ".env";
+  const defaultEnvs = [
+    {
+      render: true,
+      name: "MODEL",
+      description: "The name of LLM model to use.",
+      value: opts.model || "gpt-3.5-turbo",
+    },
+    {
+      render: true,
+      name: "OPENAI_API_KEY",
+      description: "The OpenAI API key to use.",
+      value: opts.openAiKey,
+    },
+    // Add vector database environment variables
+    ...(opts.vectorDb ? getVectorDBEnvs(opts.vectorDb) : []),
+    // Add data source environment variables
+    ...(opts.dataSources ? getDataSourceEnvs(opts.dataSources) : []),
+  ];
+  let envVars: EnvVar[] = [];
+  if (opts.framework === "fastapi") {
+    envVars = [
+      ...defaultEnvs,
+      ...[
+        {
+          name: "APP_HOST",
+          description: "The address to start the backend app.",
+          value: "0.0.0.0",
+        },
+        {
+          name: "APP_PORT",
+          description: "The port to start the backend app.",
+          value: opts.port?.toString() || "8000",
+        },
+        {
+          name: "EMBEDDING_MODEL",
+          description: "Name of the embedding model to use.",
+          value: opts.embeddingModel,
+        },
+        {
+          name: "EMBEDDING_DIM",
+          description: "Dimension of the embedding model to use.",
+        },
+        {
+          name: "LLM_TEMPERATURE",
+          description: "Temperature for sampling from the model.",
+        },
+        {
+          name: "LLM_MAX_TOKENS",
+          description: "Maximum number of tokens to generate.",
+        },
+        {
+          name: "TOP_K",
+          description:
+            "The number of similar embeddings to return when retrieving documents.",
+          value: "3",
+        },
+        {
+          name: "SYSTEM_PROMPT",
+          description: `Custom system prompt.
+Example:
+SYSTEM_PROMPT="
+We have provided context information below.
+---------------------
+{context_str}
+---------------------
+Given this information, please answer the question: {query_str}
+"`,
+        },
+        opts?.dataSources?.some(
+          (ds) => (ds.config as FileSourceConfig).useLlamaParse,
+        )
+          ? {
+              name: "LLAMA_CLOUD_API_KEY",
+              description: `The Llama Cloud API key.`,
+              value: opts.llamaCloudKey,
+            }
+          : {},
+      ],
+    ];
+  } else {
+    envVars = [
+      ...defaultEnvs,
+      ...[
+        opts.framework === "nextjs"
+          ? {
+              name: "NEXT_PUBLIC_MODEL",
+              description:
+                "The LLM model to use (hardcode to front-end artifact).",
+              value: opts.model || "gpt-3.5-turbo",
+            }
+          : {},
+      ],
+    ];
+  }
+  // Render and write env file
+  const content = renderEnvVar(envVars);
+  await fs.writeFile(path.join(root, envFileName), content);
+  console.log(`Created '${envFileName}' file. Please check the settings.`);
+};
+
+export const createFrontendEnvFile = async (
+  root: string,
+  opts: {
+    customApiPath?: string;
+    model?: string;
+  },
+) => {
+  const defaultFrontendEnvs = [
+    {
+      name: "MODEL",
+      description: "The OpenAI model to use.",
+      value: opts.model,
+    },
+    {
+      name: "NEXT_PUBLIC_MODEL",
+      description: "The OpenAI model to use (hardcode to front-end artifact).",
+      value: opts.model,
+    },
+    {
+      name: "NEXT_PUBLIC_CHAT_API",
+      description: "The backend API for chat endpoint.",
+      value: opts.customApiPath
+        ? opts.customApiPath
+        : "http://localhost:8000/api/chat",
+    },
+  ];
+  const content = renderEnvVar(defaultFrontendEnvs);
+  await fs.writeFile(path.join(root, ".env"), content);
+};

helpers/index.ts

@@ -0,0 +1,208 @@
+import { copy } from "./copy";
+import { callPackageManager } from "./install";
+
+import fs from "fs/promises";
+import path from "path";
+import { cyan } from "picocolors";
+
+import { templatesDir } from "./dir";
+import { createBackendEnvFile, createFrontendEnvFile } from "./env-variables";
+import { PackageManager } from "./get-pkg-manager";
+import { installLlamapackProject } from "./llama-pack";
+import { isHavingPoetryLockFile, tryPoetryRun } from "./poetry";
+import { installPythonTemplate } from "./python";
+import { downloadAndExtractRepo } from "./repo";
+import {
+  FileSourceConfig,
+  InstallTemplateArgs,
+  TemplateDataSource,
+  TemplateFramework,
+  TemplateVectorDB,
+} from "./types";
+import { installTSTemplate } from "./typescript";
+
+// eslint-disable-next-line max-params
+async function generateContextData(
+  framework: TemplateFramework,
+  packageManager?: PackageManager,
+  openAiKey?: string,
+  vectorDb?: TemplateVectorDB,
+  llamaCloudKey?: string,
+  useLlamaParse?: boolean,
+) {
+  if (packageManager) {
+    const runGenerate = `${cyan(
+      framework === "fastapi"
+        ? "poetry run python app/engine/generate.py"
+        : `${packageManager} run generate`,
+    )}`;
+    const openAiKeyConfigured = openAiKey || process.env["OPENAI_API_KEY"];
+    const llamaCloudKeyConfigured = useLlamaParse
+      ? llamaCloudKey || process.env["LLAMA_CLOUD_API_KEY"]
+      : true;
+    const hasVectorDb = vectorDb && vectorDb !== "none";
+    if (framework === "fastapi") {
+      if (
+        openAiKeyConfigured &&
+        llamaCloudKeyConfigured &&
+        !hasVectorDb &&
+        isHavingPoetryLockFile()
+      ) {
+        console.log(`Running ${runGenerate} to generate the context data.`);
+        const result = tryPoetryRun("python app/engine/generate.py");
+        if (!result) {
+          console.log(`Failed to run ${runGenerate}.`);
+          process.exit(1);
+        }
+        console.log(`Generated context data`);
+        return;
+      }
+    } else {
+      if (openAiKeyConfigured && vectorDb === "none") {
+        console.log(`Running ${runGenerate} to generate the context data.`);
+        await callPackageManager(packageManager, true, ["run", "generate"]);
+        return;
+      }
+    }
+
+    const settings = [];
+    if (!openAiKeyConfigured) settings.push("your OpenAI key");
+    if (!llamaCloudKeyConfigured) settings.push("your Llama Cloud key");
+    if (hasVectorDb) settings.push("your Vector DB environment variables");
+    const settingsMessage =
+      settings.length > 0 ? `After setting ${settings.join(" and ")}, ` : "";
+    const generateMessage = `run ${runGenerate} to generate the context data.`;
+    console.log(`\n${settingsMessage}${generateMessage}\n\n`);
+  }
+}
+
+const copyContextData = async (
+  root: string,
+  dataSource?: TemplateDataSource,
+) => {
+  const destPath = path.join(root, "data");
+  const dataSourceConfig = dataSource?.config as FileSourceConfig;
+
+  // Copy file
+  if (dataSource?.type === "file") {
+    if (dataSourceConfig.paths) {
+      await fs.mkdir(destPath, { recursive: true });
+      console.log(
+        "Copying data from files:",
+        dataSourceConfig.paths.toString(),
+      );
+      for (const p of dataSourceConfig.paths) {
+        await fs.copyFile(p, path.join(destPath, path.basename(p)));
+      }
+    } else {
+      console.log("Missing file path in config");
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Copy folder
+  if (dataSource?.type === "folder") {
+    // Example data does not have path config, set the default path
+    const srcPaths = dataSourceConfig.paths ?? [
+      path.join(templatesDir, "components", "data"),
+    ];
+    console.log("Copying data from folders: ", srcPaths);
+    for (const p of srcPaths) {
+      const folderName = path.basename(p);
+      const destFolderPath = path.join(destPath, folderName);
+      await fs.mkdir(destFolderPath, { recursive: true });
+      await copy("**", destFolderPath, {
+        parents: true,
+        cwd: p,
+      });
+    }
+    return;
+  }
+};
+
+const installCommunityProject = async ({
+  root,
+  communityProjectConfig,
+}: Pick<InstallTemplateArgs, "root" | "communityProjectConfig">) => {
+  const { owner, repo, branch, filePath } = communityProjectConfig!;
+  console.log("\nInstalling community project:", filePath || repo);
+  await downloadAndExtractRepo(root, {
+    username: owner,
+    name: repo,
+    branch,
+    filePath: filePath || "",
+  });
+};
+
+export const installTemplate = async (
+  props: InstallTemplateArgs & { backend: boolean },
+) => {
+  process.chdir(props.root);
+
+  if (props.template === "community" && props.communityProjectConfig) {
+    await installCommunityProject(props);
+    return;
+  }
+
+  if (props.template === "llamapack" && props.llamapack) {
+    await installLlamapackProject(props);
+    return;
+  }
+
+  if (props.framework === "fastapi") {
+    await installPythonTemplate(props);
+  } else {
+    await installTSTemplate(props);
+  }
+
+  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.
+    await createBackendEnvFile(props.root, {
+      openAiKey: props.openAiKey,
+      llamaCloudKey: props.llamaCloudKey,
+      vectorDb: props.vectorDb,
+      model: props.model,
+      embeddingModel: props.embeddingModel,
+      framework: props.framework,
+      dataSources: props.dataSources,
+      port: props.externalPort,
+    });
+
+    if (props.engine === "context") {
+      console.log("\nGenerating context data...\n");
+      props.dataSources.forEach(async (ds) => {
+        if (ds.type === "file" || ds.type === "folder") {
+          await copyContextData(props.root, ds);
+        }
+      });
+      if (
+        props.postInstallAction === "runApp" ||
+        props.postInstallAction === "dependencies"
+      ) {
+        await generateContextData(
+          props.framework,
+          props.packageManager,
+          props.openAiKey,
+          props.vectorDb,
+          props.llamaCloudKey,
+          props.dataSources.some(
+            (ds) =>
+              (ds.type === "file" || ds.type === "folder") &&
+              (ds.config as FileSourceConfig).useLlamaParse,
+          ),
+        );
+      }
+    }
+  } else {
+    // this is a frontend for a full-stack app, create .env file with model information
+    createFrontendEnvFile(props.root, {
+      model: props.model,
+      customApiPath: props.customApiPath,
+    });
+  }
+};
+
+export * from "./types";

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/python.ts

@@ -0,0 +1,306 @@
+import fs from "fs/promises";
+import path from "path";
+import { cyan, red } from "picocolors";
+import { parse, stringify } from "smol-toml";
+import terminalLink from "terminal-link";
+import { copy } from "./copy";
+import { templatesDir } from "./dir";
+import { isPoetryAvailable, tryPoetryInstall } from "./poetry";
+import { Tool } from "./tools";
+import {
+  FileSourceConfig,
+  InstallTemplateArgs,
+  TemplateDataSource,
+  TemplateVectorDB,
+} from "./types";
+
+interface Dependency {
+  name: string;
+  version?: string;
+  extras?: string[];
+}
+
+const getAdditionalDependencies = (
+  vectorDb?: TemplateVectorDB,
+  dataSource?: TemplateDataSource,
+  tools?: Tool[],
+) => {
+  const dependencies: Dependency[] = [];
+
+  // Add vector db dependencies
+  switch (vectorDb) {
+    case "mongo": {
+      dependencies.push({
+        name: "llama-index-vector-stores-mongodb",
+        version: "^0.1.3",
+      });
+      break;
+    }
+    case "pg": {
+      dependencies.push({
+        name: "llama-index-vector-stores-postgres",
+        version: "^0.1.1",
+      });
+    }
+    case "pinecone": {
+      dependencies.push({
+        name: "llama-index-vector-stores-pinecone",
+        version: "^0.1.3",
+      });
+      break;
+    }
+    case "milvus": {
+      dependencies.push({
+        name: "llama-index-vector-stores-milvus",
+        version: "^0.1.6",
+      });
+      break;
+    }
+  }
+
+  // Add data source dependencies
+  const dataSourceType = dataSource?.type;
+  if (dataSourceType === "file" || dataSourceType === "folder") {
+    // llama-index-readers-file (pdf, excel, csv) is already included in llama_index package
+    dependencies.push({
+      name: "docx2txt",
+      version: "^0.8",
+    });
+  } else if (dataSourceType === "web") {
+    dependencies.push({
+      name: "llama-index-readers-web",
+      version: "^0.1.6",
+    });
+  }
+
+  // Add tools dependencies
+  tools?.forEach((tool) => {
+    tool.dependencies?.forEach((dep) => {
+      dependencies.push(dep);
+    });
+  });
+
+  return dependencies;
+};
+
+const mergePoetryDependencies = (
+  dependencies: Dependency[],
+  existingDependencies: Record<string, Omit<Dependency, "name">>,
+) => {
+  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;
+
+    if (value.version === undefined) {
+      throw new Error(
+        `Dependency "${dependency.name}" is missing attribute "version"!`,
+      );
+    }
+
+    existingDependencies[dependency.name] = value;
+  }
+};
+
+export const addDependencies = async (
+  projectDir: string,
+  dependencies: Dependency[],
+) => {
+  if (dependencies.length === 0) return;
+
+  const FILENAME = "pyproject.toml";
+  try {
+    // Parse toml file
+    const file = path.join(projectDir, FILENAME);
+    const fileContent = await fs.readFile(file, "utf8");
+    const fileParsed = parse(fileContent);
+
+    // Modify toml dependencies
+    const tool = fileParsed.tool as any;
+    const existingDependencies = tool.poetry.dependencies;
+    mergePoetryDependencies(dependencies, existingDependencies);
+
+    // Write toml file
+    const newFileContent = stringify(fileParsed);
+    await fs.writeFile(file, newFileContent);
+
+    const dependenciesString = dependencies.map((d) => d.name).join(", ");
+    console.log(`\nAdded ${dependenciesString} to ${cyan(FILENAME)}\n`);
+  } catch (error) {
+    console.log(
+      `Error while updating dependencies for Poetry project file ${FILENAME}\n`,
+      error,
+    );
+  }
+};
+
+export const installPythonDependencies = (
+  { noRoot }: { noRoot: boolean } = { noRoot: false },
+) => {
+  if (isPoetryAvailable()) {
+    console.log(
+      `Installing python dependencies using poetry. This may take a while...`,
+    );
+    const installSuccessful = tryPoetryInstall(noRoot);
+    if (!installSuccessful) {
+      console.error(
+        red(
+          "Installing dependencies using poetry failed. Please check error log above and try running create-llama again.",
+        ),
+      );
+      process.exit(1);
+    }
+  } else {
+    console.error(
+      red(
+        `Poetry is not available in the current environment. Please check ${terminalLink(
+          "Poetry Installation",
+          `https://python-poetry.org/docs/#installation`,
+        )} to install poetry first, then run create-llama again.`,
+      ),
+    );
+    process.exit(1);
+  }
+};
+
+export const installPythonTemplate = async ({
+  root,
+  template,
+  framework,
+  engine,
+  vectorDb,
+  dataSources,
+  tools,
+  postInstallAction,
+}: Pick<
+  InstallTemplateArgs,
+  | "root"
+  | "framework"
+  | "template"
+  | "engine"
+  | "vectorDb"
+  | "dataSources"
+  | "tools"
+  | "postInstallAction"
+>) => {
+  console.log("\nInitializing Python project with template:", template, "\n");
+  const templatePath = path.join(templatesDir, "types", template, framework);
+  await copy("**", root, {
+    parents: true,
+    cwd: templatePath,
+    rename(name) {
+      switch (name) {
+        case "gitignore": {
+          return `.${name}`;
+        }
+        // README.md is ignored by webpack-asset-relocator-loader used by ncc:
+        // https://github.com/vercel/webpack-asset-relocator-loader/blob/e9308683d47ff507253e37c9bcbb99474603192b/src/asset-relocator.js#L227
+        case "README-template.md": {
+          return "README.md";
+        }
+        default: {
+          return name;
+        }
+      }
+    },
+  });
+
+  if (engine === "context") {
+    const enginePath = path.join(root, "app", "engine");
+    const compPath = path.join(templatesDir, "components");
+
+    const vectorDbDirName = vectorDb ?? "none";
+    const VectorDBPath = path.join(
+      compPath,
+      "vectordbs",
+      "python",
+      vectorDbDirName,
+    );
+    await copy("**", enginePath, {
+      parents: true,
+      cwd: VectorDBPath,
+    });
+
+    // Copy engine code
+    if (tools !== undefined && tools.length > 0) {
+      await copy("**", enginePath, {
+        parents: true,
+        cwd: path.join(compPath, "engines", "python", "agent"),
+      });
+      // Write tools_config.json
+      const configContent: Record<string, any> = {};
+      tools.forEach((tool) => {
+        configContent[tool.name] = tool.config ?? {};
+      });
+      const configFilePath = path.join(root, "tools_config.json");
+      await fs.writeFile(
+        configFilePath,
+        JSON.stringify(configContent, null, 2),
+      );
+    } else {
+      await copy("**", enginePath, {
+        parents: true,
+        cwd: path.join(compPath, "engines", "python", "chat"),
+      });
+    }
+
+    if (dataSources.length > 0 || dataSources[0].type !== "none") {
+      // Copy loader.py file to enginePath
+      await copy("loader.py", enginePath, {
+        parents: true,
+        cwd: path.join(compPath, "loaders", "python"),
+      });
+
+      // Copy data source loaders
+      const loaderPath = path.join(enginePath, "loaders");
+      for (const source of dataSources) {
+        const sourceType = source.type;
+        if (sourceType === "file" || sourceType === "folder") {
+          const sourceConfig = source.config as FileSourceConfig;
+          const loaderFolder = sourceConfig.useLlamaParse
+            ? "llama_parse"
+            : "file";
+          await copy("**", loaderPath, {
+            parents: true,
+            cwd: path.join(compPath, "loaders", "python", loaderFolder),
+          });
+        } else {
+          await copy("**", loaderPath, {
+            parents: true,
+            cwd: path.join(compPath, "loaders", "python", sourceType),
+          });
+        }
+      }
+    }
+
+    // const dataSourceType = dataSource?.type;
+    // if (dataSourceType !== undefined && dataSourceType !== "none") {
+    //   let loaderFolder: string;
+    //   if (dataSourceType === "file" || dataSourceType === "folder") {
+    //     const dataSourceConfig = dataSource?.config as FileSourceConfig;
+    //     loaderFolder = dataSourceConfig.useLlamaParse ? "llama_parse" : "file";
+    //   } else {
+    //     loaderFolder = dataSourceType;
+    //   }
+    //   await copy("**", enginePath, {
+    //     parents: true,
+    //     cwd: path.join(compPath, "loaders", "python", loaderFolder),
+    //   });
+    // }
+  }
+
+  const addOnDependencies = dataSources
+    .map((ds) => getAdditionalDependencies(vectorDb, ds, tools))
+    .flat();
+  await addDependencies(root, addOnDependencies);
+
+  if (postInstallAction === "runApp" || postInstallAction === "dependencies") {
+    installPythonDependencies();
+  }
+};

helpers/run-app.ts

@@ -0,0 +1,88 @@
+import { ChildProcess, SpawnOptions, spawn } from "child_process";
+import path from "path";
+import { TemplateFramework } from "./types";
+
+const createProcess = (
+  command: string,
+  args: string[],
+  options: SpawnOptions,
+) => {
+  return spawn(command, args, {
+    ...options,
+    shell: true,
+  })
+    .on("exit", function (code) {
+      if (code !== 0) {
+        console.log(`Child process exited with code=${code}`);
+        process.exit(1);
+      }
+    })
+    .on("error", function (err) {
+      console.log("Error when running chill process: ", err);
+      process.exit(1);
+    });
+};
+
+// eslint-disable-next-line max-params
+export async function runApp(
+  appPath: string,
+  frontend: boolean,
+  framework: TemplateFramework,
+  port?: number,
+  externalPort?: number,
+): Promise<any> {
+  let backendAppProcess: ChildProcess;
+  let frontendAppProcess: ChildProcess | undefined;
+  const frontendPort = port || 3000;
+  let backendPort = externalPort || 8000;
+
+  // Callback to kill app processes
+  process.on("exit", () => {
+    console.log("Killing app processes...");
+    backendAppProcess.kill();
+    frontendAppProcess?.kill();
+  });
+
+  let backendCommand = "";
+  let backendArgs: string[];
+  if (framework === "fastapi") {
+    backendCommand = "poetry";
+    backendArgs = [
+      "run",
+      "uvicorn",
+      "main:app",
+      "--host=0.0.0.0",
+      "--port=" + backendPort,
+    ];
+  } else if (framework === "nextjs") {
+    backendCommand = "npm";
+    backendArgs = ["run", "dev"];
+    backendPort = frontendPort;
+  } else {
+    backendCommand = "npm";
+    backendArgs = ["run", "dev"];
+  }
+
+  if (frontend) {
+    return new Promise((resolve, reject) => {
+      backendAppProcess = createProcess(backendCommand, backendArgs, {
+        stdio: "inherit",
+        cwd: path.join(appPath, "backend"),
+        env: { ...process.env, PORT: `${backendPort}` },
+      });
+      frontendAppProcess = createProcess("npm", ["run", "dev"], {
+        stdio: "inherit",
+        cwd: path.join(appPath, "frontend"),
+        env: { ...process.env, PORT: `${frontendPort}` },
+      });
+    });
+  } else {
+    return new Promise((resolve, reject) => {
+      backendAppProcess = createProcess(backendCommand, backendArgs, {
+        stdio: "inherit",
+        cwd: path.join(appPath),
+        env: { ...process.env, PORT: `${backendPort}` },
+      });
+    });
+  }
+}

helpers/tools.ts

@@ -0,0 +1,71 @@
+import { red } from "picocolors";
+
+export type Tool = {
+  display: string;
+  name: string;
+  config?: Record<string, any>;
+  dependencies?: ToolDependencies[];
+};
+export type ToolDependencies = {
+  name: string;
+  version?: string;
+};
+
+export const supportedTools: Tool[] = [
+  {
+    display: "Google Search (configuration required after installation)",
+    name: "google.GoogleSearchToolSpec",
+    config: {
+      engine:
+        "Your search engine id, see https://developers.google.com/custom-search/v1/overview#prerequisites",
+      key: "Your search api key",
+      num: 2,
+    },
+    dependencies: [
+      {
+        name: "llama-index-tools-google",
+        version: "0.1.2",
+      },
+    ],
+  },
+  {
+    display: "Wikipedia",
+    name: "wikipedia.WikipediaToolSpec",
+    dependencies: [
+      {
+        name: "llama-index-tools-wikipedia",
+        version: "0.1.2",
+      },
+    ],
+  },
+];
+
+export const getTool = (toolName: string): Tool | undefined => {
+  return supportedTools.find((tool) => tool.name === toolName);
+};
+
+export const getTools = (toolsName: string[]): Tool[] => {
+  const tools: Tool[] = [];
+  for (const toolName of toolsName) {
+    const tool = getTool(toolName);
+    if (!tool) {
+      console.log(
+        red(
+          `Error: Tool '${toolName}' is not supported. Supported tools are: ${supportedTools
+            .map((t) => t.name)
+            .join(", ")}`,
+        ),
+      );
+      process.exit(1);
+    }
+    tools.push(tool);
+  }
+  return tools;
+};
+
+export const toolsRequireConfig = (tools?: Tool[]): boolean => {
+  if (tools) {
+    return tools?.some((tool) => Object.keys(tool.config || {}).length > 0);
+  }
+  return false;
+};

helpers/types.ts

@@ -0,0 +1,61 @@
+import { PackageManager } from "../helpers/get-pkg-manager";
+import { Tool } from "./tools";
+
+export type TemplateType = "simple" | "streaming" | "community" | "llamapack";
+export type TemplateFramework = "nextjs" | "express" | "fastapi";
+export type TemplateEngine = "simple" | "context";
+export type TemplateUI = "html" | "shadcn";
+export type TemplateVectorDB = "none" | "mongo" | "pg" | "pinecone" | "milvus";
+export type TemplatePostInstallAction =
+  | "none"
+  | "VSCode"
+  | "dependencies"
+  | "runApp";
+export type TemplateDataSource = {
+  type: TemplateDataSourceType;
+  config: TemplateDataSourceConfig;
+};
+export type TemplateDataSourceType = "none" | "file" | "folder" | "web";
+export type TemplateObservability = "none" | "opentelemetry";
+// Config for both file and folder
+export type FileSourceConfig = {
+  paths?: string[];
+  useLlamaParse?: boolean;
+};
+export type WebSourceConfig = {
+  baseUrl?: string;
+  depth?: number;
+};
+export type TemplateDataSourceConfig = FileSourceConfig | WebSourceConfig;
+
+export type CommunityProjectConfig = {
+  owner: string;
+  repo: string;
+  branch: string;
+  filePath?: string;
+};
+
+export interface InstallTemplateArgs {
+  appName: string;
+  root: string;
+  packageManager: PackageManager;
+  isOnline: boolean;
+  template: TemplateType;
+  framework: TemplateFramework;
+  engine: TemplateEngine;
+  ui: TemplateUI;
+  dataSources: TemplateDataSource[];
+  eslint: boolean;
+  customApiPath?: string;
+  openAiKey?: string;
+  llamaCloudKey?: string;
+  model: string;
+  embeddingModel: string;
+  communityProjectConfig?: CommunityProjectConfig;
+  llamapack?: string;
+  vectorDb?: TemplateVectorDB;
+  externalPort?: number;
+  postInstallAction?: TemplatePostInstallAction;
+  tools?: Tool[];
+  observability?: TemplateObservability;
+}

helpers/typescript.ts

@@ -0,0 +1,271 @@
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+import { bold, cyan } from "picocolors";
+import { copy } from "../helpers/copy";
+import { callPackageManager } from "../helpers/install";
+import { templatesDir } from "./dir";
+import { PackageManager } from "./get-pkg-manager";
+import { InstallTemplateArgs } from "./types";
+
+const rename = (name: string) => {
+  switch (name) {
+    case "gitignore":
+    case "eslintrc.json": {
+      return `.${name}`;
+    }
+    // README.md is ignored by webpack-asset-relocator-loader used by ncc:
+    // https://github.com/vercel/webpack-asset-relocator-loader/blob/e9308683d47ff507253e37c9bcbb99474603192b/src/asset-relocator.js#L227
+    case "README-template.md": {
+      return "README.md";
+    }
+    default: {
+      return name;
+    }
+  }
+};
+
+export const installTSDependencies = async (
+  packageJson: any,
+  packageManager: PackageManager,
+  isOnline: boolean,
+): Promise<void> => {
+  console.log("\nInstalling dependencies:");
+  for (const dependency in packageJson.dependencies)
+    console.log(`- ${cyan(dependency)}`);
+
+  console.log("\nInstalling devDependencies:");
+  for (const dependency in packageJson.devDependencies)
+    console.log(`- ${cyan(dependency)}`);
+
+  console.log();
+
+  await callPackageManager(packageManager, isOnline).catch((error) => {
+    console.error("Failed to install TS dependencies. Exiting...");
+    process.exit(1);
+  });
+};
+
+/**
+ * Install a LlamaIndex internal template to a given `root` directory.
+ */
+export const installTSTemplate = async ({
+  appName,
+  root,
+  packageManager,
+  isOnline,
+  template,
+  framework,
+  engine,
+  ui,
+  eslint,
+  customApiPath,
+  vectorDb,
+  postInstallAction,
+  backend,
+  observability,
+}: 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 = ["**"];
+  if (!eslint) copySource.push("!eslintrc.json");
+
+  await copy(copySource, root, {
+    parents: true,
+    cwd: templatePath,
+    rename,
+  });
+
+  /**
+   * If next.js is used, update its configuration if necessary
+   */
+  if (framework === "nextjs") {
+    const nextConfigJsonFile = path.join(root, "next.config.json");
+    const nextConfigJson: any = JSON.parse(
+      await fs.readFile(nextConfigJsonFile, "utf8"),
+    );
+    if (!backend) {
+      // update next.config.json for static site generation
+      nextConfigJson.output = "export";
+      nextConfigJson.images = { unoptimized: true };
+      console.log("\nUsing static site generation\n");
+    } else {
+      if (vectorDb === "milvus") {
+        nextConfigJson.experimental.serverComponentsExternalPackages =
+          nextConfigJson.experimental.serverComponentsExternalPackages ?? [];
+        nextConfigJson.experimental.serverComponentsExternalPackages.push(
+          "@zilliz/milvus2-sdk-node",
+        );
+      }
+    }
+    await fs.writeFile(
+      nextConfigJsonFile,
+      JSON.stringify(nextConfigJson, null, 2) + os.EOL,
+    );
+
+    const webpackConfigOtelFile = path.join(root, "webpack.config.o11y.mjs");
+    if (observability === "opentelemetry") {
+      const webpackConfigDefaultFile = path.join(root, "webpack.config.mjs");
+      await fs.rm(webpackConfigDefaultFile);
+      await fs.rename(webpackConfigOtelFile, webpackConfigDefaultFile);
+    } else {
+      await fs.rm(webpackConfigOtelFile);
+    }
+  }
+
+  if (observability && observability !== "none") {
+    const chosenObservabilityPath = path.join(
+      templatesDir,
+      "components",
+      "observability",
+      "typescript",
+      observability,
+    );
+    const relativeObservabilityPath = framework === "nextjs" ? "app" : "src";
+
+    await copy(
+      "**",
+      path.join(root, relativeObservabilityPath, "observability"),
+      { cwd: chosenObservabilityPath },
+    );
+  }
+
+  /**
+   * Copy the selected chat engine files to the target directory and reference it.
+   */
+  let relativeEngineDestPath;
+  const compPath = path.join(templatesDir, "components");
+  if (engine && (framework === "express" || framework === "nextjs")) {
+    console.log("\nUsing chat engine:", engine, "\n");
+
+    let vectorDBFolder: string = engine;
+
+    if (engine !== "simple" && vectorDb) {
+      console.log("\nUsing vector DB:", vectorDb, "\n");
+      vectorDBFolder = vectorDb;
+    }
+
+    const VectorDBPath = path.join(
+      compPath,
+      "vectordbs",
+      "typescript",
+      vectorDBFolder,
+    );
+    relativeEngineDestPath =
+      framework === "nextjs"
+        ? path.join("app", "api", "chat")
+        : path.join("src", "controllers");
+    await copy("**", path.join(root, relativeEngineDestPath, "engine"), {
+      parents: true,
+      cwd: VectorDBPath,
+    });
+  }
+
+  /**
+   * Copy the selected UI files to the target directory and reference it.
+   */
+  if (framework === "nextjs" && ui !== "shadcn") {
+    console.log("\nUsing UI:", ui, "\n");
+    const uiPath = path.join(compPath, "ui", ui);
+    const destUiPath = path.join(root, "app", "components", "ui");
+    // remove the default ui folder
+    await fs.rm(destUiPath, { recursive: true });
+    // copy the selected ui folder
+    await copy("**", destUiPath, {
+      parents: true,
+      cwd: uiPath,
+      rename,
+    });
+  }
+
+  /**
+   * Update the package.json scripts.
+   */
+  const packageJsonFile = path.join(root, "package.json");
+  const packageJson: any = JSON.parse(
+    await fs.readFile(packageJsonFile, "utf8"),
+  );
+  packageJson.name = appName;
+  packageJson.version = "0.1.0";
+
+  if (framework === "nextjs" && customApiPath) {
+    console.log(
+      "\nUsing external API with custom API path:",
+      customApiPath,
+      "\n",
+    );
+    // remove the default api folder
+    const apiPath = path.join(root, "app", "api");
+    await fs.rm(apiPath, { recursive: true });
+    // modify the dev script to use the custom api path
+  }
+
+  if (engine === "context" && relativeEngineDestPath) {
+    // add generate script if using context engine
+    packageJson.scripts = {
+      ...packageJson.scripts,
+      generate: `node ${path.join(
+        relativeEngineDestPath,
+        "engine",
+        "generate.mjs",
+      )}`,
+    };
+  }
+
+  if (framework === "nextjs" && ui === "html") {
+    // remove shadcn dependencies if html ui is selected
+    packageJson.dependencies = {
+      ...packageJson.dependencies,
+      "tailwind-merge": undefined,
+      "@radix-ui/react-slot": undefined,
+      "class-variance-authority": undefined,
+      clsx: undefined,
+      "lucide-react": undefined,
+      remark: undefined,
+      "remark-code-import": undefined,
+      "remark-gfm": undefined,
+      "remark-math": undefined,
+      "react-markdown": undefined,
+      "react-syntax-highlighter": undefined,
+    };
+
+    packageJson.devDependencies = {
+      ...packageJson.devDependencies,
+      "@types/react-syntax-highlighter": undefined,
+    };
+  }
+
+  if (observability === "opentelemetry") {
+    packageJson.dependencies = {
+      ...packageJson.dependencies,
+      "@traceloop/node-server-sdk": "^0.5.19",
+    };
+
+    packageJson.devDependencies = {
+      ...packageJson.devDependencies,
+      "node-loader": "^2.0.0",
+    };
+  }
+
+  if (!eslint) {
+    // Remove packages starting with "eslint" from devDependencies
+    packageJson.devDependencies = Object.fromEntries(
+      Object.entries(packageJson.devDependencies).filter(
+        ([key]) => !key.startsWith("eslint"),
+      ),
+    );
+  }
+  await fs.writeFile(
+    packageJsonFile,
+    JSON.stringify(packageJson, null, 2) + os.EOL,
+  );
+
+  if (postInstallAction === "runApp" || postInstallAction === "dependencies") {
+    await installTSDependencies(packageJson, packageManager, isOnline);
+  }
+};

index.ts

@@ -1,6 +1,8 @@
+#!/usr/bin/env node
 /* eslint-disable import/no-extraneous-dependencies */
 import { execSync } from "child_process";
-import { Command } from "commander";
+import Commander from "commander";
+import Conf from "conf";
 import fs from "fs";
 import path from "path";
 import { bold, cyan, green, red, yellow } from "picocolors";
@@ -8,19 +10,13 @@ import prompts from "prompts";
 import terminalLink from "terminal-link";
 import checkForUpdate from "update-check";
 import { createApp } from "./create-app";
-import { EXAMPLE_FILE, getDataSources } from "./helpers/datasources";
 import { getPkgManager } from "./helpers/get-pkg-manager";
 import { isFolderEmpty } from "./helpers/is-folder-empty";
-import { initializeGlobalAgent } from "./helpers/proxy";
 import { runApp } from "./helpers/run-app";
 import { getTools } from "./helpers/tools";
 import { validateNpmName } from "./helpers/validate-pkg";
 import packageJson from "./package.json";
-import { askQuestions } from "./questions/index";
-import { QuestionArgs } from "./questions/types";
-import { onPromptState } from "./questions/utils";
-// Run the initialization function
-initializeGlobalAgent();
+import { QuestionArgs, askQuestions, onPromptState } from "./questions";
 
 let projectPath: string = "";
 
@@ -29,15 +25,20 @@ const handleSigTerm = () => process.exit(0);
 process.on("SIGINT", handleSigTerm);
 process.on("SIGTERM", handleSigTerm);
 
-const program = new Command(packageJson.name)
+const program = new Commander.Command(packageJson.name)
   .version(packageJson.version)
-  .arguments("[project-directory]")
-  .usage(`${green("[project-directory]")} [options]`)
+  .arguments("<project-directory>")
+  .usage(`${green("<project-directory>")} [options]`)
   .action((name) => {
-    if (name) {
-      projectPath = name;
-    }
+    projectPath = name;
   })
+  .option(
+    "--eslint",
+    `
+
+  Initialize with eslint config.
+`,
+  )
   .option(
     "--use-npm",
     `
@@ -57,6 +58,13 @@ const program = new Command(packageJson.name)
     `
 
   Explicitly tell the CLI to bootstrap the application using Yarn
+`,
+  )
+  .option(
+    "--reset-preferences",
+    `
+
+  Explicitly tell the CLI to reset any stored preferences
 `,
   )
   .option(
@@ -64,6 +72,13 @@ const program = new Command(packageJson.name)
     `
 
   Select a template to bootstrap the application with.
+`,
+  )
+  .option(
+    "--engine <engine>",
+    `
+
+  Select a chat engine to bootstrap the application with.
 `,
   )
   .option(
@@ -77,28 +92,7 @@ const program = new Command(packageJson.name)
     "--files <path>",
     `
   
-  Specify the path to a local file or folder for chatting.
-`,
-  )
-  .option(
-    "--example-file",
-    `
-
-  Select to use an example PDF as data source.
-`,
-  )
-  .option(
-    "--web-source <url>",
-    `
-  
-  Specify a website URL to use as a data source.
-`,
-  )
-  .option(
-    "--db-source <connection-string>",
-    `
-  
-  Specify a database connection string to use as a data source.
+    Specify the path to a local file or folder for chatting.
 `,
   )
   .option(
@@ -119,14 +113,20 @@ const program = new Command(packageJson.name)
     "--frontend",
     `
 
-  Generate a frontend for your backend.
+  Whether to generate a frontend for your backend.
 `,
   )
   .option(
-    "--no-frontend",
+    "--model <model>",
     `
 
-  Do not generate a frontend for your backend.
+  Select OpenAI model to use. E.g. gpt-3.5-turbo.
+`,
+  )
+  .option(
+    "--embedding-model <embeddingModel>",
+    `
+  Select OpenAI embedding model to use. E.g. text-embedding-ada-002.
 `,
   )
   .option(
@@ -134,6 +134,13 @@ const program = new Command(packageJson.name)
     `
 
   Select UI port.
+`,
+  )
+  .option(
+    "--external-port <external>",
+    `
+
+  Select external port.
 `,
   )
   .option(
@@ -156,108 +163,63 @@ const program = new Command(packageJson.name)
 
   Specify the tools you want to use by providing a comma-separated list. For example, 'wikipedia.WikipediaToolSpec,google.GoogleSearchToolSpec'. Use 'none' to not using any tools.
 `,
-    (tools, _) => {
-      if (tools === "none") {
-        return [];
-      } else {
-        return getTools(tools.split(","));
-      }
-    },
   )
   .option(
-    "--use-llama-parse",
+    "--llama-parse",
     `
-
-  Enable LlamaParse.
+    Enable LlamaParse.
 `,
   )
   .option(
     "--llama-cloud-key <key>",
     `
-  
   Provide a LlamaCloud API key.
 `,
   )
+  .option(
+    "--list-server-models",
+    "Fetch available LLM and embedding models from OpenAI API.",
+  )
   .option(
     "--observability <observability>",
-    `
-    
-  Specify observability tools to use. Eg: none, opentelemetry
-`,
-  )
-  .option(
-    "--ask-models",
-    `
-
-  Allow interactive selection of LLM and embedding models of different model providers.
-`,
-    false,
-  )
-  .option(
-    "--pro",
-    `
-
-  Allow interactive selection of all features.
-`,
-    false,
-  )
-  .option(
-    "--use-case <useCase>",
-    `
-
-  Select which use case to use for the multi-agent template (e.g: financial_report, blog).
-`,
+    "Specify observability tools to use. Eg: none, opentelemetry",
   )
   .allowUnknownOption()
   .parse(process.argv);
-
-const options = program.opts();
-
-if (
-  process.argv.includes("--no-llama-parse") ||
-  options.template === "reflex"
-) {
-  options.useLlamaParse = false;
+if (process.argv.includes("--no-frontend")) {
+  program.frontend = false;
 }
-if (process.argv.includes("--no-files")) {
-  options.dataSources = [];
-} else if (process.argv.includes("--example-file")) {
-  options.dataSources = getDataSources(options.files, options.exampleFile);
-} else if (process.argv.includes("--llamacloud")) {
-  options.dataSources = [EXAMPLE_FILE];
-  options.vectorDb = "llamacloud";
-} else if (process.argv.includes("--web-source")) {
-  options.dataSources = [
-    {
-      type: "web",
-      config: {
-        baseUrl: options.webSource,
-        prefix: options.webSource,
-        depth: 1,
-      },
-    },
-  ];
-} else if (process.argv.includes("--db-source")) {
-  options.dataSources = [
-    {
-      type: "db",
-      config: {
-        uri: options.dbSource,
-        queries: options.dbQuery || "SELECT * FROM mytable",
-      },
-    },
-  ];
+if (process.argv.includes("--no-eslint")) {
+  program.eslint = false;
+}
+if (process.argv.includes("--tools")) {
+  if (program.tools === "none") {
+    program.tools = [];
+  } else {
+    program.tools = getTools(program.tools.split(","));
+  }
+}
+if (process.argv.includes("--no-llama-parse")) {
+  program.llamaParse = false;
 }
 
-const packageManager = !!options.useNpm
+const packageManager = !!program.useNpm
   ? "npm"
-  : !!options.usePnpm
+  : !!program.usePnpm
     ? "pnpm"
-    : !!options.useYarn
+    : !!program.useYarn
       ? "yarn"
       : getPkgManager();
 
 async function run(): Promise<void> {
+  const conf = new Conf({ projectName: "create-llama" });
+
+  if (program.resetPreferences) {
+    conf.clear();
+    console.log(`Preferences reset successfully`);
+    return;
+  }
+
   if (typeof projectPath === "string") {
     projectPath = projectPath.trim();
   }
@@ -320,15 +282,34 @@ async function run(): Promise<void> {
     process.exit(1);
   }
 
-  const answers = await askQuestions(options as unknown as QuestionArgs);
+  const preferences = (conf.get("preferences") || {}) as QuestionArgs;
+  await askQuestions(program as unknown as QuestionArgs, preferences);
 
   await createApp({
-    ...answers,
+    template: program.template,
+    framework: program.framework,
+    engine: program.engine,
+    ui: program.ui,
     appPath: resolvedProjectPath,
     packageManager,
+    eslint: program.eslint,
+    frontend: program.frontend,
+    openAiKey: program.openAiKey,
+    llamaCloudKey: program.llamaCloudKey,
+    model: program.model,
+    embeddingModel: program.embeddingModel,
+    communityProjectConfig: program.communityProjectConfig,
+    llamapack: program.llamapack,
+    vectorDb: program.vectorDb,
+    externalPort: program.externalPort,
+    postInstallAction: program.postInstallAction,
+    dataSources: program.dataSources,
+    tools: program.tools,
+    observability: program.observability,
   });
+  conf.set("preferences", preferences);
 
-  if (answers.postInstallAction === "VSCode") {
+  if (program.postInstallAction === "VSCode") {
     console.log(`Starting VSCode in ${root}...`);
     try {
       execSync(`code . --new-window --goto README.md`, {
@@ -352,9 +333,15 @@ Please check ${cyan(
         )} for more information.`,
       );
     }
-  } else if (answers.postInstallAction === "runApp") {
+  } else if (program.postInstallAction === "runApp") {
     console.log(`Running app in ${root}...`);
-    await runApp(root, answers.template, answers.framework, options.port);
+    await runApp(
+      root,
+      program.frontend,
+      program.framework,
+      program.port,
+      program.externalPort,
+    );
   }
 }
 

package.json

@@ -1,39 +1,74 @@
 {
-	"name": "create-llama-monorepo",
-	"version": "1.0.0",
-	"private": true,
-	"description": "Monorepo for create-llama",
-	"keywords": [
-		"rag",
-		"llamaindex"
-	],
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/run-llama/create-llama"
-	},
-	"license": "MIT",
-	"workspaces": [
-		"packages/*"
-	],
-	"scripts": {
-		"prepare": "husky",
-		"new-snapshot": "pnpm -r build && changeset version --snapshot",
-		"new-version": "pnpm -r build && changeset version",
-		"release": "pnpm -r build && changeset publish",
-		"release-snapshot": "pnpm -r build && changeset publish --tag snapshot",
-		"build": "pnpm -r build",
-		"e2e": "pnpm -r e2e",
-		"dev": "pnpm -r dev",
-		"format": "pnpm -r format",
-		"format:write": "pnpm -r format:write",
-		"lint": "pnpm -r lint"
-	},
-	"devDependencies": {
-		"@changesets/cli": "^2.27.1",
-		"husky": "^9.0.10"
-	},
-	"packageManager": "pnpm@9.0.5",
-	"engines": {
-		"node": ">=16.14.0"
-	}
+  "name": "create-llama",
+  "version": "0.0.29",
+  "keywords": [
+    "rag",
+    "llamaindex",
+    "next.js"
+  ],
+  "description": "Create LlamaIndex-powered apps with one command",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/run-llama/LlamaIndexTS",
+    "directory": "packages/create-llama"
+  },
+  "license": "MIT",
+  "bin": {
+    "create-llama": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rimraf --glob ./dist ./templates/**/__pycache__ ./templates/**/node_modules ./templates/**/poetry.lock",
+    "format": "prettier --ignore-unknown --cache --check .",
+    "format:write": "prettier --ignore-unknown --write .",
+    "dev": "ncc build ./index.ts -w -o dist/",
+    "build": "npm run clean && ncc build ./index.ts -o ./dist/ --minify --no-cache --no-source-map-register",
+    "lint": "eslint . --ignore-pattern dist --ignore-pattern e2e/cache",
+    "e2e": "playwright test",
+    "prepare": "husky",
+    "release": "pnpm run build && changeset publish",
+    "new-version": "pnpm run build && changeset version"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.41.1",
+    "@types/async-retry": "1.4.2",
+    "@types/ci-info": "2.0.0",
+    "@types/cross-spawn": "6.0.0",
+    "@types/node": "^20.11.7",
+    "@types/prompts": "2.0.1",
+    "@types/tar": "6.1.5",
+    "@types/validate-npm-package-name": "3.0.0",
+    "@vercel/ncc": "0.38.1",
+    "async-retry": "1.3.1",
+    "async-sema": "3.0.1",
+    "ci-info": "github:watson/ci-info#f43f6a1cefff47fb361c88cf4b943fdbcaafe540",
+    "commander": "2.20.0",
+    "conf": "10.2.0",
+    "cross-spawn": "7.0.3",
+    "fast-glob": "3.3.1",
+    "got": "10.7.0",
+    "picocolors": "1.0.0",
+    "prompts": "2.1.0",
+    "rimraf": "^5.0.5",
+    "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",
+    "wait-port": "^1.1.0",
+    "@changesets/cli": "^2.27.1",
+    "eslint": "^8.56.0",
+    "husky": "^9.0.10",
+    "prettier": "^3.2.5",
+    "prettier-plugin-organize-imports": "^3.2.4",
+    "typescript": "^5.3.3",
+    "eslint-config-prettier": "^8.10.0",
+    "ora": "^8.0.1"
+  },
+  "engines": {
+    "node": ">=16.14.0"
+  },
+  "packageManager": "pnpm@8.15.1"
 }

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/CHANGELOG.md

@@ -1,952 +0,0 @@
-# create-llama
-
-## 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
-
-- 61204a1: chore: bump LITS 0.9
-
-### Patch Changes
-
-- 9e723c3: Standardize the code of the workflow use case (Python)
-- d5da55b: feat: add components.json to use CLI
-- c1552eb: chore: move wikipedia tool to create-llama
-
-## 0.3.28
-
-### Patch Changes
-
-- 4e06714: Fix the error: Unable to view file sources due to CORS.
-
-## 0.3.27
-
-### Patch Changes
-
-- b4e41aa: Add deep research over own documents use case (Python)
-
-## 0.3.26
-
-### Patch Changes
-
-- f73d46b: Fix missing copy of the multiagent code
-
-## 0.3.25
-
-### Patch Changes
-
-- 5450096: bump: react 19 stable
-
-## 0.3.24
-
-### Patch Changes
-
-- a84743c: Change --agents paramameter to --use-case
-- a84743c: Add LlamaCloud support for Reflex templates
-- a7a6592: Fix the npm issue on the full-stack Python template
-- fc5e56e: bump: code interpreter v1
-
-## 0.3.23
-
-### Patch Changes
-
-- 9077cae: Add contract review use case (Python)
-
-## 0.3.22
-
-### Patch Changes
-
-- 25667d4: Make OpenAPI spec usable by custom GPTs
-
-## 0.3.21
-
-### Patch Changes
-
-- 95227a7: Add query endpoint
-
-## 0.3.20
-
-### Patch Changes
-
-- 27d2499: Bump the LlamaCloud library and fix breaking changes (Python).
-
-## 0.3.19
-
-### Patch Changes
-
-- f9a057d: Add support multimodal indexes (e.g. from LlamaCloud)
-- aedd73d: bump: chat-ui
-
-## 0.3.18
-
-### Patch Changes
-
-- fe90a7e: chore: bump ai v4
-- 02b2473: Show streaming errors in Python, optimize system prompts for tool usage and set the weather tool as default for the Agentic RAG use case
-- 63e961e: Use auto_routed retriever mode for LlamaCloudIndex
-
-## 0.3.17
-
-### Patch Changes
-
-- 28c8808: Add fly.io deployment
-- 0a7dfcf: Generate NEXT_PUBLIC_CHAT_API for NextJS backend to specify alternative backend
-
-## 0.3.16
-
-### Patch Changes
-
-- 8b371d8: Set pydantic version to <2.10 to avoid incompatibility with llama-index.
-- 30fe269: Deactive duckduckgo tool for TS
-- 30fe269: Replace DuckDuckGo by Wikipedia tool for agentic template
-
-## 0.3.15
-
-### Patch Changes
-
-- fc5b266: Improve DX for Python template (use one deployment instead of two)
-- f8f97d2: Add support for python 3.13
-
-## 0.3.14
-
-### Patch Changes
-
-- 00f0b3a: fix: dont include user message in chat history
-- 4663dec: chore: bump react19 rc
-- 44b34fb: chore: update eslint 9, nextjs 15, react 19
-- 6925676: feat: use latest chat UI
-
-## 0.3.13
-
-### Patch Changes
-
-- 282eaa0: Ensure that the index and document store are created when uploading a file with no available index.
-
-## 0.3.12
-
-### Patch Changes
-
-- 6edea6a: Optimize generated workflow code for Python
-- 8431b78: Optimize Typescript multi-agent code
-- 8431b78: Add form filling use case (Typescript)
-
-## 0.3.11
-
-### Patch Changes
-
-- 2b8aaa8: Add support for local models via Hugging Face
-- b9570b2: Fix: use generic LLMAgent instead of OpenAIAgent (adds support for Gemini and Anthropic for Agentic RAG)
-- 1fe21f8: Fix the highlight.js issue with the Next.js static build
-- 00009ae: feat: import pdf css
-
-## 0.3.10
-
-### Patch Changes
-
-- 9172fed: feat: bump LITS 0.8.2
-- 78ccde7: feat: use llamaindex chat-ui for nextjs frontend
-
-## 0.3.9
-
-### Patch Changes
-
-- ed59927: Add form filling use case (Python)
-
-## 0.3.8
-
-### Patch Changes
-
-- 4a83469: Add multi-agent financial report for Typescript (and update LITS to 0.7.10)
-
-## 0.3.7
-
-### Patch Changes
-
-- fa80378: DocumentInfo working with relative URLs
-
-## 0.3.6
-
-### Patch Changes
-
-- 0182368: Fix the streaming issue to prevent the UI from hanging.
-
-## 0.3.5
-
-### Patch Changes
-
-- 2209409: Add financial report as the default use case in the multi-agent template (Python).
-
-## 0.3.4
-
-### Patch Changes
-
-- 384a136: Fix import error if the artifact tool is selected
-
-## 0.3.3
-
-### Patch Changes
-
-- 99b8247: Simplify and unify handling file uploads
-
-## 0.3.2
-
-### Patch Changes
-
-- 6d1b6b9: Update README.md for pro mode
-
-## 0.3.1
-
-### Patch Changes
-
-- f3577c5: Fix event streaming is blocked
-- f3577c5: Add upload file to sandbox (artifact and code interpreter)
-
-## 0.3.0
-
-### Minor Changes
-
-- 7562cb4: Simplified default questions and added pro mode
-
-### Patch Changes
-
-- 0a69fe0: fix: missing params when init Astra vectorstore
-- 98a82b0: docs: chroma env variables
-
-## 0.2.19
-
-### Patch Changes
-
-- 3d41488: feat: use selected llamacloud for multiagent
-
-## 0.2.18
-
-### Patch Changes
-
-- 75e1f61: Fix cannot query public document from llamacloud
-- 88220f1: fix workflow doesn't stop when user presses stop generation button
-- 75e1f61: Fix typescript templates cannot upload file to llamacloud
-- 88220f1: Bump llama_index@0.11.17
-
-## 0.2.17
-
-### Patch Changes
-
-- cd3fcd0: bump: use LlamaIndexTS 0.6.18
-- 6335de1: Fix using LlamaCloud selector does not use the configured values in the environment (Python)
-
-## 0.2.16
-
-### Patch Changes
-
-- 0e78ba4: Fix: programmatically ensure index for LlamaCloud
-- 0e78ba4: Fix .env not loaded on poetry run generate
-- 7f4ac22: Don't need to run generate script for LlamaCloud
-- 5263bde: Use selected LlamaCloud index in multi-agent template
-
-## 0.2.15
-
-### Patch Changes
-
-- 16e6124: Bump package for llamatrace observability
-- 3790ca0: Add multi-agent task selector for TS template
-- d18f039: Add e2b code artifact tool for the FastAPI template
-
-## 0.2.14
-
-### Patch Changes
-
-- 5a7216e: feat: implement artifact tool in TS
-
-## 0.2.13
-
-### Patch Changes
-
-- 04ddebc: Add publisher agent to multi-agents for generating documents (PDF and HTML)
-- 04ddebc: Allow tool selection for multi-agents (Python and TS)
-
-## 0.2.12
-
-### Patch Changes
-
-- 70f7dca: feat: add test deps for llamaparse
-- ef070c0: Add multi agents template for Typescript
-
-## 0.2.11
-
-### Patch Changes
-
-- 7c2a3f6: fix: postgres import
-
-## 0.2.10
-
-### Patch Changes
-
-- cb8d535: Fix only produces one agent event
-
-## 0.2.9
-
-### Patch Changes
-
-- 0213fe0: Update dependencies for vector stores and add e2e test to ensure that they work as expected.
-
-## 0.2.8
-
-### Patch Changes
-
-- 0031e67: Bump llama-index to 0.11.11 for the multi-agent template
-
-## 0.2.7
-
-### Patch Changes
-
-- 505b8e9: bump: use latest ai package version
-- cf3ec97: Dynamically select model for Groq
-- 8c1087f: feat: enhance style for markdown
-
-## 0.2.6
-
-### Patch Changes
-
-- adc40cf: fix: vercel ai update crash sending annotations
-
-## 0.2.5
-
-### Patch Changes
-
-- 38a8be8: fix: filter in mongo vector store
-
-## 0.2.4
-
-### Patch Changes
-
-- 917e862: Fix errors in building the frontend
-
-## 0.2.3
-
-### Patch Changes
-
-- b6da3c2: Ensure the generation script always works
-
-## 0.2.2
-
-### Patch Changes
-
-- 8105c5c: Add env config for next questions feature
-
-## 0.2.1
-
-### Patch Changes
-
-- 6a409cb: Bump web and database reader packages
-
-## 0.2.0
-
-### Minor Changes
-
-- 435109f: Add multi-agents template based on workflows
-
-## 0.1.44
-
-### Patch Changes
-
-- bedde2b: Change metadata filters to use already existing documents in LlamaCloud Index
-- 5cd12fa: Use one callback manager per request
-- 5cd12fa: Bump llama_index version to 0.11.1
-- fd4abb3: Fix to use filename for uploaded documents in NextJS
-- 2f8feab: Simplify CLI interface
-
-## 0.1.43
-
-### Patch Changes
-
-- 4fa2b76: feat: implement citation for TS
-
-## 0.1.42
-
-### Patch Changes
-
-- 8f670a9: Allow relative URL in documents
-
-## 0.1.41
-
-### Patch Changes
-
-- 57e7638: Use the retrieval defaults from LlamaCloud
-
-## 0.1.40
-
-### Patch Changes
-
-- 8ce4a85: Add UI for extractor template
-
-## 0.1.39
-
-### Patch Changes
-
-- 3fb93c7: Use LlamaCloud pipeline for data ingestion in TS (private file uploads and generate script)
-
-## 0.1.38
-
-### Patch Changes
-
-- bd5e39a: Fix error that files in sub folders of 'data' are not displayed
-
-## 0.1.37
-
-### Patch Changes
-
-- 9fd832c: Add in-text citation references
-
-## 0.1.36
-
-### Patch Changes
-
-- 2b7a5d8: Fix: private file upload not working in Python without LlamaCloud
-
-## 0.1.35
-
-### Patch Changes
-
-- 81ef7f0: Use LlamaCloud pipeline for data ingestion (private file uploads and generate script)
-
-## 0.1.34
-
-### Patch Changes
-
-- c49a5e1: Add error handling for generating the next question
-- c49a5e1: Fix wrong api key variable in Azure OpenAI provider
-
-## 0.1.33
-
-### Patch Changes
-
-- d746c75: Add Weaviate vector store (Typescript)
-
-## 0.1.32
-
-### Patch Changes
-
-- 3ec5163: Add Weaviate vector database support (Python)
-
-## 0.1.31
-
-### Patch Changes
-
-- 04a9c71: Cluster nodes by document
-
-## 0.1.30
-
-### Patch Changes
-
-- 09e3022: Add support for LlamaTrace (Python)
-- c06ec4f: Fix imports for MongoDB
-- b6dd7a9: Always send chat data when submit message
-
-## 0.1.29
-
-### Patch Changes
-
-- 8890e27: Let user change indexes in LlamaCloud projects
-
-## 0.1.28
-
-### Patch Changes
-
-- 9a09e8c: Fix Vercel deployment
-
-## 0.1.27
-
-### Patch Changes
-
-- c5c7eee: Make components reusable for chat-llamaindex
-
-## 0.1.26
-
-### Patch Changes
-
-- f43399c: Add metadatafilters to context chat engine (Typescript)
-
-## 0.1.25
-
-### Patch Changes
-
-- c67daeb: fix: missing set private to false for default generate.py
-
-## 0.1.24
-
-### Patch Changes
-
-- 43474a5: Configure LlamaCloud organization ID for Python
-- cf11b23: Add Azure code interpreter for Python and TS
-- fd9fb42: Add Azure OpenAI as model provider
-- 5c13646: Fix starter questions not working in python backend
-
-## 0.1.23
-
-### Patch Changes
-
-- 6bd76fb: Add template for structured extraction
-
-## 0.1.22
-
-### Patch Changes
-
-- b0becaa: Add e2e testing for llamacloud datasource
-- df9cca5: Upgrade pdf viewer
-
-## 0.1.21
-
-### Patch Changes
-
-- bd4714c: Filter private documents for Typescript (Using MetadataFilters) and update to LlamaIndexTS 0.5.7
-- 58e6c15: Add using LlamaParse for private file uploader
-- 455ab68: Display files in sources using LlamaCloud indexes.
-- 23b7357: Use gpt-4o-mini as default model
-- 0900413: Add suggestions for next questions.
-
-## 0.1.20
-
-### Patch Changes
-
-- 624c721: Update to LlamaIndex 0.10.55
-
-## 0.1.19
-
-### Patch Changes
-
-- df96159: Use Qdrant FastEmbed as local embedding provider
-- 32fb32a: Support upload document files: pdf, docx, txt
-
-## 0.1.18
-
-### Patch Changes
-
-- d1026ea: support Mistral as llm and embedding
-- a221cfc: Use LlamaParse for all the file types that it supports (if activated)
-
-## 0.1.17
-
-### Patch Changes
-
-- 9ecd061: Add new template for a multi-agents app
-
-## 0.1.16
-
-### Patch Changes
-
-- a0aab03: Add T-System's LLMHUB as a model provider
-
-## 0.1.15
-
-### Patch Changes
-
-- 64732f0: Fix the issue of images not showing with the sandbox URL from OpenAI's models
-- aeb6fef: use llamacloud for chat
-
-## 0.1.14
-
-### Patch Changes
-
-- f2c3389: chore: update to llamaindex 0.4.3
-- 5093b37: Remove non-working file selectors for Linux
-
-## 0.1.13
-
-### Patch Changes
-
-- b3c969d: Add image generator tool
-
-## 0.1.12
-
-### Patch Changes
-
-- aa69014: Fix NextJS for TS 5.2
-
-## 0.1.11
-
-### Patch Changes
-
-- 48b96ff: Add DuckDuckGo search tool
-- 9c9decb: Reuse function tool instances and improve e2b interpreter tool for Python
-- 02ed277: Add Groq as a model provider
-- 0748f2e: Remove hard-coded Gemini supported models
-
-## 0.1.10
-
-### Patch Changes
-
-- 9112d08: Add OpenAPI tool for Typescript
-- 8f03f8d: Add OLLAMA_REQUEST_TIMEOUT variable to config Ollama timeout (Python)
-- 8f03f8d: Apply nest_asyncio for llama parse
-
-## 0.1.9
-
-### Patch Changes
-
-- a42fa53: Add CSV upload
-- 563b51d: Fix Vercel streaming (python) to stream data events instantly
-- d60b3c5: Add E2B code interpreter tool for FastAPI
-- 956538e: Add OpenAPI action tool for FastAPI
-
-## 0.1.8
-
-### Patch Changes
-
-- cd50a33: Add interpreter tool for TS using e2b.dev
-
-## 0.1.7
-
-### Patch Changes
-
-- 260d37a: Add system prompt env variable for TS
-- bbd5b8d: Fix postgres connection leaking issue
-- bb53425: Support HTTP proxies by setting the GLOBAL_AGENT_HTTP_PROXY env variable
-- 69c2e16: Fix streaming for Express
-- 7873bfb: Update Ollama provider to run with the base URL from the environment variable
-
-## 0.1.6
-
-### Patch Changes
-
-- 56537a1: Display PDF files in source nodes
-
-## 0.1.5
-
-### Patch Changes
-
-- 84db798: feat: support display latex in chat markdown
-
-## 0.1.4
-
-### Patch Changes
-
-- 0bc8e75: Use ingestion pipeline for dedicated vector stores (Python only)
-- cb1001d: Add ChromaDB vector store
-
-## 0.1.3
-
-### Patch Changes
-
-- 416073d: Directly import vector stores to work with NextJS
-
-## 0.1.2
-
-### Patch Changes
-
-- 056e376: Add support for displaying tool outputs (including weather widget as example)
-
-## 0.1.1
-
-### Patch Changes
-
-- 7bd3ed5: Support Anthropic and Gemini as model providers
-- 7bd3ed5: Support new agents from LITS 0.3
-- cfb5257: Display events (e.g. retrieving nodes) per chat message
-
-## 0.1.0
-
-### Minor Changes
-
-- f1c3e8d: Add Llama3 and Phi3 support using Ollama
-
-### Patch Changes
-
-- a0dec80: Use `gpt-4-turbo` model as default. Upgrade Python llama-index to 0.10.28
-- 753229d: Remove asking for AI models and use defaults instead (OpenAIs GPT-4 Vision Preview and Embeddings v3). Use `--ask-models` CLI parameter to select models.
-- 1d78202: Add observability for Python
-- 6acccd2: Use poetry run generate to generate embeddings for FastAPI
-- 9efcffe: Use Settings object for LlamaIndex configuration
-- 418bf9b: refactor: use tsx instead of ts-node
-- 1be69a5: Add Qdrant support
-
-## 0.0.32
-
-### Patch Changes
-
-- 625ed4d: Support Astra VectorDB
-- 922e0ce: Remove UI question (use shadcn as default). Use `html` UI by calling create-llama with --ui html parameter
-- ce2f24d: Update loaders and tools config to yaml format (for Python)
-- e8db041: Let user select multiple datasources (URLs, files and folders)
-- c06d4af: Add nodes to the response (Python)
-- 29b17ee: Allow using agents without any data source
-- 665c26c: Add redirect to documentation page when accessing the base URL (FastAPI)
-- 78ded9e: Add Dockerfile templates for Typescript and Python
-- 99e758f: Merge non-streaming and streaming template to one
-- b3f2685: Add support for agent generation for Typescript
-- 2739714: Use a database (MySQL or PostgreSQL) as a data source
-
-## 0.0.31
-
-### Patch Changes
-
-- 56faee0: Added windows e2e tests
-- 60ed8fe: Added missing environment variable config for URL data source
-- 60ed8fe: Fixed tool usage by freezing llama-index package versions
-
-## 0.0.30
-
-### Patch Changes
-
-- 3af6328: Add support for llamaparse using Typescript
-- dd92b91: Add fetching llm and embedding models from server
-- bac1b43: Add Milvus vector database
-
-## 0.0.29
-
-### Patch Changes
-
-- edd24c2: Add observability with openllmetry
-- 403fc6f: Minor bug fixes to improve DX (missing .env value and updated error messages)
-- 0f79757: Ability to download community submodules
-
-## 0.0.28
-
-### Patch Changes
-
-- 89a49f4: Add more config variables to .env file
-- fdf48dd: Add "Start in VSCode" option to postInstallAction
-- fdf48dd: Add devcontainers to generated code
-
-## 0.0.27
-
-### Patch Changes
-
-- 2d29350: Add LlamaParse option when selecting a pdf file or a folder (FastAPI only)
-- b354f23: Add embedding model option to create-llama (FastAPI only)
-
-## 0.0.26
-
-### Patch Changes
-
-- 09d532e: feat: generate llama pack project from llama index
-- cfdd6db: feat: add pinecone support to create llama
-- ef25d69: upgrade llama-index package to version v0.10.7 for create-llama app
-- 50dfd7b: update fastapi for CVE-2024-24762
-
-## 0.0.25
-
-### Patch Changes
-
-- d06a85b: Add option to create an agent by selecting tools (Google, Wikipedia)
-- 7b7329b: Added latest turbo models for GPT-3.5 and GPT 4
-
-## 0.0.24
-
-### Patch Changes
-
-- ba95ca3: Use condense plus context chat engine for FastAPI as default
-
-## 0.0.23
-
-### Patch Changes
-
-- c680af6: Fixed issues with locating templates path
-
-## 0.0.22
-
-### Patch Changes
-
-- 6dd401e: Add an option to provide an URL and chat with the website data (FastAPI only)
-- e9b87ef: Select a folder as data source and support more file types (.pdf, .doc, .docx, .xls, .xlsx, .csv)
-
-## 0.0.20
-
-### Patch Changes
-
-- 27d55fd: Add an option to provide an URL and chat with the website data
-
-## 0.0.19
-
-### Patch Changes
-
-- 3a29a80: Add node_modules to gitignore in Express backends
-- fe03aaa: feat: generate llama pack example
-
-## 0.0.18
-
-### Patch Changes
-
-- 88d3b41: fix packaging
-
-## 0.0.17
-
-### Patch Changes
-
-- fa17f7e: Add an option that allows the user to run the generated app
-- 9e5d8e1: Add an option to select a local PDF file as data source
-
-## 0.0.16
-
-### Patch Changes
-
-- a73942d: Fix: Bundle mongo dependency with NextJS
-- 9492cc6: Feat: Added option to automatically install dependencies (for Python and TS)
-- f74dea5: Feat: Show images in chat messages using GPT4 Vision (Express and NextJS only)
-
-## 0.0.15
-
-### Patch Changes
-
-- 8e124e5: feat: support showing image on chat message
-
-## 0.0.14
-
-### Patch Changes
-
-- 2e6b36e: fix: re-organize file structure
-- 2b356c8: fix: relative path incorrect
-
-## 0.0.13
-
-### Patch Changes
-
-- Added PostgreSQL vector store (for Typescript and Python)
-- Improved async handling in FastAPI
-
-## 0.0.12
-
-### Patch Changes
-
-- 9c5e22a: Added cross-env so frontends with Express/FastAPI backends are working under Windows
-- 5ab65eb: Bring Python templates with TS templates to feature parity
-- 9c5e22a: Added vector DB selector to create-llama (starting with MongoDB support)
-
-## 0.0.11
-
-### Patch Changes
-
-- 2aeb341: - Added option to create a new project based on community templates
-  - Added OpenAI model selector for NextJS projects
-  - Added GPT4 Vision support (and file upload)
-
-## 0.0.10
-
-### Patch Changes
-
-- Bugfixes (thanks @marcusschiesser)
-
-## 0.0.9
-
-### Patch Changes
-
-- acfe232: Deployment fixes (thanks @seldo)
-
-## 0.0.8
-
-### Patch Changes
-
-- 8cdb07f: Fix Next deployment (thanks @seldo and @marcusschiesser)
-
-## 0.0.7
-
-### Patch Changes
-
-- 9f9f293: Added more to README and made it easier to switch models (thanks @seldo)
-
-## 0.0.6
-
-### Patch Changes
-
-- 4431ec7: Label bug fix (thanks @marcusschiesser)
-
-## 0.0.5
-
-### Patch Changes
-
-- 25257f4: Fix issue where it doesn't find OpenAI Key when running npm run generate (#182) (thanks @RayFernando1337)
-
-## 0.0.4
-
-### Patch Changes
-
-- 031e926: Update create-llama readme (thanks @logan-markewich)
-
-## 0.0.3
-
-### Patch Changes
-
-- 91b42a3: change version (thanks @marcusschiesser)
-
-## 0.0.2
-
-### Patch Changes
-
-- e2a6805: Hello Create Llama (thanks @marcusschiesser)

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

@@ -1,248 +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, 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();
-
-  // 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/shared/llamaindexserver_template.spec.ts

@@ -1,107 +0,0 @@
-/* eslint-disable turbo/no-undeclared-env-vars */
-import { expect, test } from "@playwright/test";
-import { ChildProcess } from "child_process";
-import fs from "fs";
-import path from "path";
-import type {
-  TemplateFramework,
-  TemplatePostInstallAction,
-  TemplateUI,
-} from "../../helpers";
-import { createTestDir, runCreateLlama, type AppType } from "../utils";
-
-const templateFramework: TemplateFramework = process.env.FRAMEWORK
-  ? (process.env.FRAMEWORK as TemplateFramework)
-  : "fastapi";
-const dataSource: string = "--example-file";
-const templateUI: TemplateUI = "shadcn";
-const templatePostInstallAction: TemplatePostInstallAction = "runApp";
-const appType: AppType = "--frontend";
-const userMessage = "Write a blog post about physical standards for letters";
-const templateUseCases = ["financial_report", "agentic_rag", "deep_research"];
-
-for (const useCase of templateUseCases) {
-  test.describe(`Test use case ${useCase} ${templateFramework} ${dataSource} ${templateUI} ${appType} ${templatePostInstallAction}`, async () => {
-    test.skip(
-      process.platform !== "linux" ||
-        process.env.DATASOURCE === "--no-files" ||
-        templateFramework === "express",
-      "The llamaindexserver template currently only works with nextjs, fastapi. We also only run on Linux to speed up tests.",
-    );
-    let port: number;
-    let cwd: string;
-    let name: string;
-    let appProcess: ChildProcess;
-    // Only test without using vector db for now
-    const vectorDb = "none";
-
-    test.beforeAll(async () => {
-      port = Math.floor(Math.random() * 10000) + 10000;
-      cwd = await createTestDir();
-      const result = await runCreateLlama({
-        cwd,
-        templateType: "llamaindexserver",
-        templateFramework,
-        dataSource,
-        vectorDb,
-        port,
-        postInstallAction: templatePostInstallAction,
-        templateUI,
-        appType,
-        useCase,
-      });
-      name = result.projectName;
-      appProcess = result.appProcess;
-    });
-
-    test("App folder should exist", async () => {
-      const dirExists = fs.existsSync(path.join(cwd, name));
-      expect(dirExists).toBeTruthy();
-    });
-
-    test("Frontend should have a title", async ({ page }) => {
-      test.skip(
-        templatePostInstallAction !== "runApp" ||
-          templateFramework === "express",
-      );
-      await page.goto(`http://localhost:${port}`);
-      await expect(page.getByText("Built by LlamaIndex")).toBeVisible({
-        timeout: 5 * 60 * 1000,
-      });
-    });
-
-    test("Frontend should be able to submit a message and receive the start of a streamed response", async ({
-      page,
-    }) => {
-      test.skip(
-        templatePostInstallAction !== "runApp" ||
-          useCase === "financial_report" ||
-          useCase === "deep_research" ||
-          templateFramework === "express",
-        "Skip chat tests for financial report and deep research.",
-      );
-      await page.goto(`http://localhost:${port}`);
-      await page.fill("form textarea", userMessage);
-
-      const responsePromise = page.waitForResponse((res) =>
-        res.url().includes("/api/chat"),
-      );
-
-      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();
-    });
-
-    // clean processes
-    test.afterAll(async () => {
-      appProcess?.kill();
-    });
-  });
-}

packages/create-llama/e2e/shared/reflex_template.spec.ts

@@ -1,64 +0,0 @@
-/* eslint-disable turbo/no-undeclared-env-vars */
-import { expect, test } from "@playwright/test";
-import { ChildProcess } from "child_process";
-import fs from "fs";
-import path from "path";
-import { TemplateFramework, TemplateUseCase } from "../../helpers";
-import { createTestDir, runCreateLlama } from "../utils";
-
-const templateFramework: TemplateFramework = process.env.FRAMEWORK
-  ? (process.env.FRAMEWORK as TemplateFramework)
-  : "fastapi";
-const dataSource: string = process.env.DATASOURCE
-  ? process.env.DATASOURCE
-  : "--example-file";
-const templateUseCases: TemplateUseCase[] = ["extractor", "contract_review"];
-
-// The reflex template currently only works with FastAPI and files (and not on Windows)
-if (
-  process.platform !== "win32" &&
-  templateFramework === "fastapi" &&
-  dataSource === "--example-file"
-) {
-  for (const useCase of templateUseCases) {
-    test.describe(`Test reflex template ${useCase} ${templateFramework} ${dataSource}`, async () => {
-      let appPort: number;
-      let name: string;
-      let appProcess: ChildProcess;
-      let cwd: string;
-
-      // Create reflex app
-      test.beforeAll(async () => {
-        cwd = await createTestDir();
-        appPort = Math.floor(Math.random() * 10000) + 10000;
-        const result = await runCreateLlama({
-          cwd,
-          templateType: "reflex",
-          templateFramework: "fastapi",
-          dataSource: "--example-file",
-          vectorDb: "none",
-          port: appPort,
-          postInstallAction: "runApp",
-          useCase,
-        });
-        name = result.projectName;
-        appProcess = result.appProcess;
-      });
-
-      test.afterAll(async () => {
-        appProcess.kill();
-      });
-
-      test("App folder should exist", async () => {
-        const dirExists = fs.existsSync(path.join(cwd, name));
-        expect(dirExists).toBeTruthy();
-      });
-      test("Frontend should have a title", async ({ page }) => {
-        await page.goto(`http://localhost:${appPort}`);
-        await expect(page.getByText("Built by LlamaIndex")).toBeVisible({
-          timeout: 2000 * 60,
-        });
-      });
-    });
-  }
-}

packages/create-llama/e2e/shared/streaming_template.spec.ts

@@ -1,128 +0,0 @@
-/* eslint-disable turbo/no-undeclared-env-vars */
-import { expect, test } from "@playwright/test";
-import { ChildProcess } from "child_process";
-import fs from "fs";
-import path from "path";
-import type {
-  TemplateFramework,
-  TemplatePostInstallAction,
-  TemplateUI,
-} from "../../helpers";
-import { createTestDir, runCreateLlama, type AppType } from "../utils";
-
-const templateFramework: TemplateFramework = process.env.FRAMEWORK
-  ? (process.env.FRAMEWORK as TemplateFramework)
-  : "fastapi";
-const dataSource: string = process.env.DATASOURCE
-  ? process.env.DATASOURCE
-  : "--example-file";
-const templateUI: TemplateUI = "shadcn";
-const templatePostInstallAction: TemplatePostInstallAction = "runApp";
-
-const llamaCloudProjectName = "create-llama";
-const llamaCloudIndexName = "e2e-test";
-
-const appType: AppType = templateFramework === "fastapi" ? "--frontend" : "";
-const userMessage =
-  dataSource !== "--no-files" ? "Physical standard for letters" : "Hello";
-
-test.describe(`Test streaming template ${templateFramework} ${dataSource} ${templateUI} ${appType} ${templatePostInstallAction}`, async () => {
-  const isNode18 = process.version.startsWith("v18");
-  const isLlamaCloud = dataSource === "--llamacloud";
-  // llamacloud is using File API which is not supported on node 18
-  if (isNode18 && isLlamaCloud) {
-    test.skip(true, "Skipping tests for Node 18 and LlamaCloud data source");
-  }
-
-  let port: number;
-  let cwd: string;
-  let name: string;
-  let appProcess: ChildProcess;
-  // Only test without using vector db for now
-  const vectorDb = "none";
-
-  test.beforeAll(async () => {
-    port = Math.floor(Math.random() * 10000) + 10000;
-    cwd = await createTestDir();
-    const result = await runCreateLlama({
-      cwd,
-      templateType: "streaming",
-      templateFramework,
-      dataSource,
-      vectorDb,
-      port,
-      postInstallAction: templatePostInstallAction,
-      templateUI,
-      appType,
-      llamaCloudProjectName,
-      llamaCloudIndexName,
-    });
-    name = result.projectName;
-    appProcess = result.appProcess;
-  });
-
-  test("App folder should exist", async () => {
-    const dirExists = fs.existsSync(path.join(cwd, name));
-    expect(dirExists).toBeTruthy();
-  });
-
-  test("Frontend should have a title", async ({ page }) => {
-    test.skip(
-      templatePostInstallAction !== "runApp" || templateFramework === "express",
-    );
-    await page.goto(`http://localhost:${port}`);
-    await expect(page.getByText("Built by LlamaIndex")).toBeVisible();
-  });
-
-  test("Frontend should be able to submit a message and receive a response", async ({
-    page,
-  }) => {
-    test.skip(
-      templatePostInstallAction !== "runApp" || templateFramework === "express",
-    );
-    await page.goto(`http://localhost:${port}`);
-    await page.fill("form textarea", userMessage);
-    const [response] = await Promise.all([
-      page.waitForResponse(
-        (res) => {
-          return res.url().includes("/api/chat") && res.status() === 200;
-        },
-        {
-          timeout: 1000 * 60,
-        },
-      ),
-      page.click("form button[type=submit]"),
-    ]);
-    const text = await response.text();
-    console.log("AI response when submitting message: ", text);
-    expect(response.ok()).toBeTruthy();
-  });
-
-  test("Backend frameworks should response when calling non-streaming chat API", async ({
-    request,
-  }) => {
-    test.skip(templatePostInstallAction !== "runApp");
-    test.skip(templateFramework === "nextjs");
-    const response = await request.post(
-      `http://localhost:${port}/api/chat/request`,
-      {
-        data: {
-          messages: [
-            {
-              role: "user",
-              content: userMessage,
-            },
-          ],
-        },
-      },
-    );
-    const text = await response.text();
-    console.log("AI response when calling API: ", text);
-    expect(response.ok()).toBeTruthy();
-  });
-
-  // clean processes
-  test.afterAll(async () => {
-    appProcess?.kill();
-  });
-});

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

@@ -1,105 +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, 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 --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/e2e/utils.ts

@@ -1,201 +0,0 @@
-import { ChildProcess, exec } from "child_process";
-import crypto from "node:crypto";
-import { mkdir } from "node:fs/promises";
-import * as path from "path";
-import waitPort from "wait-port";
-import {
-  TemplateFramework,
-  TemplatePostInstallAction,
-  TemplateType,
-  TemplateUI,
-  TemplateVectorDB,
-} from "../helpers";
-
-export type AppType = "--frontend" | "--no-frontend" | "";
-
-export type CreateLlamaResult = {
-  projectName: string;
-  appProcess: ChildProcess;
-};
-
-export type RunCreateLlamaOptions = {
-  cwd: string;
-  templateType: TemplateType;
-  templateFramework: TemplateFramework;
-  dataSource: string;
-  vectorDb: TemplateVectorDB;
-  port: number;
-  postInstallAction: TemplatePostInstallAction;
-  templateUI?: TemplateUI;
-  appType?: AppType;
-  llamaCloudProjectName?: string;
-  llamaCloudIndexName?: string;
-  tools?: string;
-  useLlamaParse?: boolean;
-  observability?: string;
-  useCase?: string;
-};
-
-export async function runCreateLlama({
-  cwd,
-  templateType,
-  templateFramework,
-  dataSource,
-  vectorDb,
-  port,
-  postInstallAction,
-  templateUI,
-  appType,
-  llamaCloudProjectName,
-  llamaCloudIndexName,
-  tools,
-  useLlamaParse,
-  observability,
-  useCase,
-}: RunCreateLlamaOptions): Promise<CreateLlamaResult> {
-  if (!process.env.OPENAI_API_KEY || !process.env.LLAMA_CLOUD_API_KEY) {
-    throw new Error(
-      "Setting the OPENAI_API_KEY and LLAMA_CLOUD_API_KEY is mandatory to run tests",
-    );
-  }
-  const name = [
-    templateType,
-    templateFramework,
-    dataSource.split(" ")[0],
-    templateUI,
-    appType,
-  ].join("-");
-
-  // Handle different data source types
-  let dataSourceArgs = [];
-  if (dataSource.includes("--web-source" || "--db-source")) {
-    const webSource = dataSource.split(" ")[1];
-    dataSourceArgs.push("--web-source", webSource);
-  } else if (dataSource.includes("--db-source")) {
-    const dbSource = dataSource.split(" ")[1];
-    dataSourceArgs.push("--db-source", dbSource);
-  } else {
-    dataSourceArgs.push(dataSource);
-  }
-
-  const commandArgs = [
-    "create-llama",
-    name,
-    "--template",
-    templateType,
-    "--framework",
-    templateFramework,
-    ...dataSourceArgs,
-    "--vector-db",
-    vectorDb,
-    "--use-npm",
-    "--port",
-    port,
-    "--post-install-action",
-    postInstallAction,
-    "--tools",
-    tools ?? "none",
-    "--observability",
-    "none",
-  ];
-
-  if (templateUI) {
-    commandArgs.push("--ui", templateUI);
-  }
-  if (appType) {
-    commandArgs.push(appType);
-  }
-  if (useLlamaParse) {
-    commandArgs.push("--use-llama-parse");
-  } else {
-    commandArgs.push("--no-llama-parse");
-  }
-  if (observability) {
-    commandArgs.push("--observability", observability);
-  }
-  if (
-    (templateType === "multiagent" ||
-      templateType === "reflex" ||
-      templateType === "llamaindexserver") &&
-    useCase
-  ) {
-    commandArgs.push("--use-case", useCase);
-  }
-
-  const command = commandArgs.join(" ");
-  console.log(`running command '${command}' in ${cwd}`);
-  const appProcess = exec(command, {
-    cwd,
-    env: {
-      ...process.env,
-      LLAMA_CLOUD_PROJECT_NAME: llamaCloudProjectName,
-      LLAMA_CLOUD_INDEX_NAME: llamaCloudIndexName,
-    },
-  });
-  appProcess.stderr?.on("data", (data) => {
-    console.error(data.toString());
-  });
-  appProcess.on("exit", (code) => {
-    if (code !== 0 && code !== null) {
-      throw new Error(`create-llama command failed with exit code ${code}`);
-    }
-  });
-
-  // Wait for app to start
-  if (postInstallAction === "runApp") {
-    await waitPorts([port]);
-  } else if (postInstallAction === "dependencies") {
-    await waitForProcess(appProcess, 1000 * 60); // wait 1 min for dependencies to be resolved
-  } else {
-    // wait 10 seconds for create-llama to exit
-    await waitForProcess(appProcess, 1000 * 10);
-  }
-
-  return {
-    projectName: name,
-    appProcess,
-  };
-}
-
-export async function createTestDir() {
-  const cwd = path.join(__dirname, "cache", crypto.randomUUID());
-  await mkdir(cwd, { recursive: true });
-  return cwd;
-}
-
-async function waitPorts(ports: number[]): Promise<void> {
-  const waitForPort = async (port: number): Promise<void> => {
-    await waitPort({
-      host: "localhost",
-      port: port,
-      // wait max. 5 mins for start up of app
-      timeout: 1000 * 60 * 5,
-    });
-  };
-  try {
-    await Promise.all(ports.map(waitForPort));
-  } catch (err) {
-    console.error(err);
-    throw err;
-  }
-}
-
-async function waitForProcess(
-  process: ChildProcess,
-  timeoutMs: number,
-): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      reject(new Error("Process timeout error"));
-    }, timeoutMs);
-
-    process.on("exit", (code) => {
-      clearTimeout(timeout);
-      if (code !== 0 && code !== null) {
-        reject(new Error("Process exited with non-zero code"));
-      } else {
-        resolve();
-      }
-    });
-  });
-}

packages/create-llama/helpers/datasources.ts

@@ -1,142 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-import yaml, { Document } from "yaml";
-import { templatesDir } from "./dir";
-import { DbSourceConfig, TemplateDataSource, WebSourceConfig } from "./types";
-
-export const EXAMPLE_FILE: TemplateDataSource = {
-  type: "file",
-  config: {
-    path: path.join(templatesDir, "components", "data", "101.pdf"),
-  },
-};
-
-export const EXAMPLE_10K_SEC_FILES: TemplateDataSource[] = [
-  {
-    type: "file",
-    config: {
-      url: new URL(
-        "https://s2.q4cdn.com/470004039/files/doc_earnings/2023/q4/filing/_10-K-Q4-2023-As-Filed.pdf",
-      ),
-      filename: "apple_10k_report.pdf",
-    },
-  },
-  {
-    type: "file",
-    config: {
-      url: new URL(
-        "https://ir.tesla.com/_flysystem/s3/sec/000162828024002390/tsla-20231231-gen.pdf",
-      ),
-      filename: "tesla_10k_report.pdf",
-    },
-  },
-];
-
-export const EXAMPLE_GDPR: TemplateDataSource = {
-  type: "file",
-  config: {
-    url: new URL(
-      "https://eur-lex.europa.eu/legal-content/EN/TXT/PDF/?uri=CELEX:32016R0679",
-    ),
-    filename: "gdpr.pdf",
-  },
-};
-
-export const AI_REPORTS: TemplateDataSource = {
-  type: "file",
-  config: {
-    url: new URL(
-      "https://www.europarl.europa.eu/RegData/etudes/ATAG/2024/760392/EPRS_ATA(2024)760392_EN.pdf",
-    ),
-    filename: "EPRS_ATA_2024_760392_EN.pdf",
-  },
-};
-
-export function getDataSources(
-  files?: string,
-  exampleFile?: boolean,
-): TemplateDataSource[] | undefined {
-  let dataSources: TemplateDataSource[] | undefined = undefined;
-  if (files) {
-    // If user specified files option, then the program should use context engine
-    dataSources = files.split(",").map((filePath) => ({
-      type: "file",
-      config: {
-        path: filePath,
-      },
-    }));
-  }
-  if (exampleFile) {
-    dataSources = [...(dataSources ? dataSources : []), EXAMPLE_FILE];
-  }
-  return dataSources;
-}
-
-export async function writeLoadersConfig(
-  root: string,
-  dataSources: TemplateDataSource[],
-  useLlamaParse?: boolean,
-) {
-  const loaderConfig: Record<string, any> = {};
-
-  // Always set file loader config
-  loaderConfig.file = createFileLoaderConfig(useLlamaParse);
-
-  if (dataSources.some((ds) => ds.type === "web")) {
-    loaderConfig.web = createWebLoaderConfig(dataSources);
-  }
-
-  const dbLoaders = dataSources.filter((ds) => ds.type === "db");
-  if (dbLoaders.length > 0) {
-    loaderConfig.db = createDbLoaderConfig(dbLoaders);
-  }
-
-  // Create a new Document with the loaderConfig
-  const yamlDoc = new Document(loaderConfig);
-
-  // Write loaders config
-  const loaderConfigPath = path.join(root, "config", "loaders.yaml");
-  await fs.mkdir(path.join(root, "config"), { recursive: true });
-  await fs.writeFile(loaderConfigPath, yaml.stringify(yamlDoc));
-}
-
-function createWebLoaderConfig(dataSources: TemplateDataSource[]): any {
-  const webLoaderConfig: Record<string, any> = {};
-
-  // Create config for browser driver arguments
-  webLoaderConfig.driver_arguments = [
-    "--no-sandbox",
-    "--disable-dev-shm-usage",
-  ];
-
-  // Create config for urls
-  const urlConfigs = dataSources
-    .filter((ds) => ds.type === "web")
-    .map((ds) => {
-      const dsConfig = ds.config as WebSourceConfig;
-      return {
-        base_url: dsConfig.baseUrl,
-        prefix: dsConfig.prefix,
-        depth: dsConfig.depth,
-      };
-    });
-  webLoaderConfig.urls = urlConfigs;
-
-  return webLoaderConfig;
-}
-
-function createFileLoaderConfig(useLlamaParse?: boolean): any {
-  return {
-    use_llama_parse: useLlamaParse,
-  };
-}
-
-function createDbLoaderConfig(dbLoaders: TemplateDataSource[]): any {
-  return dbLoaders.map((ds) => {
-    const dsConfig = ds.config as DbSourceConfig;
-    return {
-      uri: dsConfig.uri,
-      queries: [dsConfig.queries],
-    };
-  });
-}

packages/create-llama/helpers/env-variables.ts

@@ -1,636 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-import { TOOL_SYSTEM_PROMPT_ENV_VAR, Tool } from "./tools";
-import {
-  InstallTemplateArgs,
-  ModelConfig,
-  TemplateDataSource,
-  TemplateFramework,
-  TemplateObservability,
-  TemplateType,
-  TemplateVectorDB,
-} from "./types";
-
-import { TSYSTEMS_LLMHUB_API_URL } from "./providers/llmhub";
-
-const DEFAULT_SYSTEM_PROMPT =
-  "You are a helpful assistant who helps users with their questions.";
-
-const DATA_SOURCES_PROMPT =
-  "You have access to a knowledge base including the facts that you should start with to find the answer for the user question. Use the query engine tool to retrieve the facts from the knowledge base.";
-
-export type EnvVar = {
-  name?: string;
-  description?: string;
-  value?: string;
-};
-
-const renderEnvVar = (envVars: EnvVar[]): string => {
-  return envVars.reduce(
-    (prev, env) =>
-      prev +
-      (env.description
-        ? `# ${env.description.replaceAll("\n", "\n# ")}\n`
-        : "") +
-      (env.name
-        ? env.value
-          ? `${env.name}=${env.value}\n\n`
-          : `# ${env.name}=\n\n`
-        : ""),
-    "",
-  );
-};
-
-const getVectorDBEnvs = (
-  vectorDb?: TemplateVectorDB,
-  framework?: TemplateFramework,
-  template?: TemplateType,
-): EnvVar[] => {
-  if (!vectorDb || !framework) {
-    return [];
-  }
-  switch (vectorDb) {
-    case "mongo":
-      return [
-        {
-          name: "MONGODB_URI",
-          description:
-            "For generating a connection URI, see https://www.mongodb.com/docs/manual/reference/connection-string/ \nThe MongoDB connection URI.",
-        },
-        {
-          name: "MONGODB_DATABASE",
-        },
-        {
-          name: "MONGODB_VECTORS",
-        },
-        {
-          name: "MONGODB_VECTOR_INDEX",
-        },
-      ];
-    case "pg":
-      return [
-        {
-          name: "PG_CONNECTION_STRING",
-          description:
-            "For generating a connection URI, see https://supabase.com/vector\nThe PostgreSQL connection string.",
-        },
-      ];
-
-    case "pinecone":
-      return [
-        {
-          name: "PINECONE_API_KEY",
-          description:
-            "Configuration for Pinecone vector store\nThe Pinecone API key.",
-        },
-        {
-          name: "PINECONE_ENVIRONMENT",
-        },
-        {
-          name: "PINECONE_INDEX_NAME",
-        },
-      ];
-    case "milvus":
-      return [
-        {
-          name: "MILVUS_ADDRESS",
-          description:
-            "The address of the Milvus server. Eg: http://localhost:19530",
-          value: "http://localhost:19530",
-        },
-        {
-          name: "MILVUS_COLLECTION",
-          description:
-            "The name of the Milvus collection to store the vectors.",
-          value: "llamacollection",
-        },
-        {
-          name: "MILVUS_USERNAME",
-          description: "The username to access the Milvus server.",
-        },
-        {
-          name: "MILVUS_PASSWORD",
-          description: "The password to access the Milvus server.",
-        },
-      ];
-    case "astra":
-      return [
-        {
-          name: "ASTRA_DB_APPLICATION_TOKEN",
-          description: "The generated app token for your Astra database",
-        },
-        {
-          name: "ASTRA_DB_ENDPOINT",
-          description: "The API endpoint for your Astra database",
-        },
-        {
-          name: "ASTRA_DB_COLLECTION",
-          description: "The name of the collection in your Astra database",
-        },
-      ];
-    case "qdrant":
-      return [
-        {
-          name: "QDRANT_URL",
-          description:
-            "The qualified REST URL of the Qdrant server. Eg: http://localhost:6333",
-        },
-        {
-          name: "QDRANT_COLLECTION",
-          description: "The name of Qdrant collection to use.",
-        },
-        {
-          name: "QDRANT_API_KEY",
-          description:
-            "Optional API key for authenticating requests to Qdrant.",
-        },
-      ];
-    case "llamacloud":
-      return [
-        {
-          name: "LLAMA_CLOUD_INDEX_NAME",
-          description:
-            "The name of the LlamaCloud index to use (part of the LlamaCloud project).",
-          value: "test",
-        },
-        {
-          name: "LLAMA_CLOUD_PROJECT_NAME",
-          description: "The name of the LlamaCloud project.",
-          value: "Default",
-        },
-        {
-          name: "LLAMA_CLOUD_BASE_URL",
-          description:
-            "The base URL for the LlamaCloud API. Only change this for non-production environments",
-          value: "https://api.cloud.llamaindex.ai",
-        },
-        {
-          name: "LLAMA_CLOUD_ORGANIZATION_ID",
-          description:
-            "The organization ID for the LlamaCloud project (uses default organization if not specified)",
-        },
-        ...(framework === "nextjs" && template !== "llamaindexserver"
-          ? // activate index selector per default (not needed for non-NextJS backends as it's handled by createFrontendEnvFile)
-            [
-              {
-                name: "NEXT_PUBLIC_USE_LLAMACLOUD",
-                description:
-                  "Let's the user change indexes in LlamaCloud projects",
-                value: "true",
-              },
-            ]
-          : []),
-      ];
-    case "chroma":
-      const envs = [
-        {
-          name: "CHROMA_COLLECTION",
-          description: "The name of the collection in your Chroma database",
-        },
-        {
-          name: "CHROMA_HOST",
-          description: "The hostname for your Chroma database. Eg: localhost",
-        },
-        {
-          name: "CHROMA_PORT",
-          description: "The port for your Chroma database. Eg: 8000",
-        },
-      ];
-      // TS Version doesn't support config local storage path
-      if (framework === "fastapi") {
-        envs.push({
-          name: "CHROMA_PATH",
-          description: `The local path to the Chroma database. 
-Specify this if you are using a local Chroma database. 
-Otherwise, use CHROMA_HOST and CHROMA_PORT config above`,
-        });
-      }
-      return envs;
-    case "weaviate":
-      return [
-        {
-          name: "WEAVIATE_CLUSTER_URL",
-          description:
-            "The URL of the Weaviate cloud cluster, see: https://weaviate.io/developers/wcs/connect",
-        },
-        {
-          name: "WEAVIATE_API_KEY",
-          description: "The API key for the Weaviate cloud cluster",
-        },
-        {
-          name: "WEAVIATE_INDEX_NAME",
-          description:
-            "(Optional) The collection name to use, default is LlamaIndex if not specified",
-        },
-      ];
-    default:
-      return template !== "llamaindexserver"
-        ? [
-            {
-              name: "STORAGE_CACHE_DIR",
-              description: "The directory to store the local storage cache.",
-              value: ".cache",
-            },
-          ]
-        : [];
-  }
-};
-
-const getModelEnvs = (modelConfig: ModelConfig): EnvVar[] => {
-  return [
-    {
-      name: "MODEL_PROVIDER",
-      description: "The provider for the AI models to use.",
-      value: modelConfig.provider,
-    },
-    {
-      name: "MODEL",
-      description: "The name of LLM model to use.",
-      value: modelConfig.model,
-    },
-    {
-      name: "EMBEDDING_MODEL",
-      description: "Name of the embedding model to use.",
-      value: modelConfig.embeddingModel,
-    },
-    {
-      name: "EMBEDDING_DIM",
-      description: "Dimension of the embedding model to use.",
-      value: modelConfig.dimensions.toString(),
-    },
-    {
-      name: "CONVERSATION_STARTERS",
-      description: "The questions to help users get started (multi-line).",
-    },
-    ...(modelConfig.provider === "openai"
-      ? [
-          {
-            name: "OPENAI_API_KEY",
-            description: "The OpenAI API key to use.",
-            value: modelConfig.apiKey,
-          },
-          {
-            name: "LLM_TEMPERATURE",
-            description: "Temperature for sampling from the model.",
-          },
-          {
-            name: "LLM_MAX_TOKENS",
-            description: "Maximum number of tokens to generate.",
-          },
-        ]
-      : []),
-    ...(modelConfig.provider === "anthropic"
-      ? [
-          {
-            name: "ANTHROPIC_API_KEY",
-            description: "The Anthropic API key to use.",
-            value: modelConfig.apiKey,
-          },
-        ]
-      : []),
-    ...(modelConfig.provider === "groq"
-      ? [
-          {
-            name: "GROQ_API_KEY",
-            description: "The Groq API key to use.",
-            value: modelConfig.apiKey,
-          },
-        ]
-      : []),
-    ...(modelConfig.provider === "gemini"
-      ? [
-          {
-            name: "GOOGLE_API_KEY",
-            description: "The Google API key to use.",
-            value: modelConfig.apiKey,
-          },
-        ]
-      : []),
-    ...(modelConfig.provider === "ollama"
-      ? [
-          {
-            name: "OLLAMA_BASE_URL",
-            description:
-              "The base URL for the Ollama API. Eg: http://127.0.0.1:11434",
-          },
-        ]
-      : []),
-    ...(modelConfig.provider === "mistral"
-      ? [
-          {
-            name: "MISTRAL_API_KEY",
-            description: "The Mistral API key to use.",
-            value: modelConfig.apiKey,
-          },
-        ]
-      : []),
-    ...(modelConfig.provider === "azure-openai"
-      ? [
-          {
-            name: "AZURE_OPENAI_API_KEY",
-            description: "The Azure OpenAI key to use.",
-            value: modelConfig.apiKey,
-          },
-          {
-            name: "AZURE_OPENAI_ENDPOINT",
-            description: "The Azure OpenAI endpoint to use.",
-          },
-          {
-            name: "AZURE_OPENAI_API_VERSION",
-            description: "The Azure OpenAI API version to use.",
-          },
-          {
-            name: "AZURE_OPENAI_LLM_DEPLOYMENT",
-            description:
-              "The Azure OpenAI deployment to use for LLM deployment.",
-          },
-          {
-            name: "AZURE_OPENAI_EMBEDDING_DEPLOYMENT",
-            description:
-              "The Azure OpenAI deployment to use for embedding deployment.",
-          },
-        ]
-      : []),
-    ...(modelConfig.provider === "huggingface"
-      ? [
-          {
-            name: "EMBEDDING_BACKEND",
-            description:
-              "The backend to use for the Sentence Transformers embedding model, either 'torch', 'onnx', or 'openvino'. Defaults to 'onnx'.",
-          },
-          {
-            name: "EMBEDDING_TRUST_REMOTE_CODE",
-            description:
-              "Whether to trust remote code for the embedding model, required for some models with custom code.",
-          },
-        ]
-      : []),
-    ...(modelConfig.provider === "t-systems"
-      ? [
-          {
-            name: "T_SYSTEMS_LLMHUB_BASE_URL",
-            description:
-              "The base URL for the T-Systems AI Foundation Model API. Eg: http://localhost:11434",
-            value: TSYSTEMS_LLMHUB_API_URL,
-          },
-          {
-            name: "T_SYSTEMS_LLMHUB_API_KEY",
-            description: "API Key for T-System's AI Foundation Model.",
-            value: modelConfig.apiKey,
-          },
-        ]
-      : []),
-  ];
-};
-
-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`,
-          },
-        ]
-      : [];
-  if (framework === "fastapi") {
-    result.push(
-      ...[
-        {
-          name: "APP_HOST",
-          description: "The address to start the FastAPI app.",
-          value: "0.0.0.0",
-        },
-        {
-          name: "APP_PORT",
-          description: "The port to start the FastAPI app.",
-          value: sPort,
-        },
-      ],
-    );
-  }
-  if (framework === "nextjs" && template !== "llamaindexserver") {
-    result.push({
-      name: "NEXT_PUBLIC_CHAT_API",
-      description:
-        "The API for the chat endpoint. Set when using a custom backend (e.g. Express). Use full URL like http://localhost:8000/api/chat",
-    });
-  }
-  return result;
-};
-
-const getEngineEnvs = (): EnvVar[] => {
-  return [
-    {
-      name: "TOP_K",
-      description:
-        "The number of similar embeddings to return when retrieving documents.",
-    },
-  ];
-};
-
-const getToolEnvs = (tools?: Tool[]): EnvVar[] => {
-  if (!tools?.length) return [];
-  const toolEnvs: EnvVar[] = [];
-  tools.forEach((tool) => {
-    if (tool.envVars?.length) {
-      toolEnvs.push(
-        // Don't include the system prompt env var here
-        // It should be handled separately by merging with the default system prompt
-        ...tool.envVars.filter(
-          (env) => env.name !== TOOL_SYSTEM_PROMPT_ENV_VAR,
-        ),
-      );
-    }
-  });
-  return toolEnvs;
-};
-
-const getSystemPromptEnv = (
-  tools?: Tool[],
-  dataSources?: TemplateDataSource[],
-  template?: TemplateType,
-): EnvVar[] => {
-  const systemPromptEnv: EnvVar[] = [];
-  // build tool system prompt by merging all tool system prompts
-  // multiagent template doesn't need system prompt
-  if (template !== "multiagent") {
-    let toolSystemPrompt = "";
-    tools?.forEach((tool) => {
-      const toolSystemPromptEnv = tool.envVars?.find(
-        (env) => env.name === TOOL_SYSTEM_PROMPT_ENV_VAR,
-      );
-      if (toolSystemPromptEnv) {
-        toolSystemPrompt += toolSystemPromptEnv.value + "\n";
-      }
-    });
-
-    const systemPrompt =
-      '"' +
-      DEFAULT_SYSTEM_PROMPT +
-      (dataSources?.length ? `\n${DATA_SOURCES_PROMPT}` : "") +
-      (toolSystemPrompt ? `\n${toolSystemPrompt}` : "") +
-      '"';
-
-    systemPromptEnv.push({
-      name: "SYSTEM_PROMPT",
-      description: "The system prompt for the AI model.",
-      value: systemPrompt,
-    });
-  }
-  if (tools?.length == 0 && (dataSources?.length ?? 0 > 0)) {
-    const citationPrompt = `'You have provided information from a knowledge base that has been passed to you in nodes of information.
-Each node has useful metadata such as node ID, file name, page, etc.
-Please add the citation to the data node for each sentence or paragraph that you reference in the provided information.
-The citation format is: . [citation:<node_id>]()
-Where the <node_id> is the unique identifier of the data node.
-
-Example:
-We have two nodes:
-  node_id: xyz
-  file_name: llama.pdf
-  
-  node_id: abc
-  file_name: animal.pdf
-
-User question: Tell me a fun fact about Llama.
-Your answer:
-A baby llama is called "Cria" [citation:xyz]().
-It often live in desert [citation:abc]().
-It\\'s cute animal.
-'`;
-    systemPromptEnv.push({
-      name: "SYSTEM_CITATION_PROMPT",
-      description:
-        "An additional system prompt to add citation when responding to user questions.",
-      value: citationPrompt,
-    });
-  }
-
-  return systemPromptEnv;
-};
-
-const getTemplateEnvs = (template?: TemplateType): EnvVar[] => {
-  const nextQuestionEnvs: EnvVar[] = [
-    {
-      name: "NEXT_QUESTION_PROMPT",
-      description: `Customize prompt to generate the next question suggestions based on the conversation history.
-Disable this prompt to disable the next question suggestions feature.`,
-      value: `"You're a helpful assistant! Your task is to suggest the next question that user might ask. 
-Here is the conversation history
----------------------
-{conversation}
----------------------
-Given the conversation history, please give me 3 questions that user might ask next!
-Your answer should be wrapped in three sticks which follows the following format:
-\`\`\`
-<question 1>
-<question 2>
-<question 3>
-\`\`\`"`,
-    },
-  ];
-
-  if (template === "multiagent" || template === "streaming") {
-    return nextQuestionEnvs;
-  }
-  return [];
-};
-
-const getObservabilityEnvs = (
-  observability?: TemplateObservability,
-): EnvVar[] => {
-  if (observability === "llamatrace") {
-    return [
-      {
-        name: "PHOENIX_API_KEY",
-        description:
-          "API key for LlamaTrace observability. Retrieve from https://llamatrace.com/login",
-      },
-    ];
-  }
-  return [];
-};
-
-export const createBackendEnvFile = async (
-  root: string,
-  opts: Pick<
-    InstallTemplateArgs,
-    | "llamaCloudKey"
-    | "vectorDb"
-    | "modelConfig"
-    | "framework"
-    | "dataSources"
-    | "template"
-    | "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),
-    // Add environment variables of each component
-    ...(opts.template === "llamaindexserver"
-      ? [
-          {
-            name: "OPENAI_API_KEY",
-            description: "The OpenAI API key to use.",
-            value: opts.modelConfig.apiKey,
-          },
-        ]
-      : [
-          // don't use this stuff for llama-indexserver
-          ...getModelEnvs(opts.modelConfig),
-          ...getEngineEnvs(),
-          ...getTemplateEnvs(opts.template),
-          ...getObservabilityEnvs(opts.observability),
-          ...getSystemPromptEnv(opts.tools, opts.dataSources, opts.template),
-        ]),
-  ];
-  // Render and write env file
-  const content = renderEnvVar(envVars);
-  await fs.writeFile(path.join(root, envFileName), content);
-  console.log(`Created '${envFileName}' file. Please check the settings.`);
-};
-
-export const createFrontendEnvFile = async (
-  root: string,
-  opts: {
-    vectorDb?: TemplateVectorDB;
-  },
-) => {
-  const defaultFrontendEnvs = [
-    {
-      name: "NEXT_PUBLIC_USE_LLAMACLOUD",
-      description: "Let's the user change indexes in LlamaCloud projects",
-      value: opts.vectorDb === "llamacloud" ? "true" : "false",
-    },
-  ];
-  const content = renderEnvVar(defaultFrontendEnvs);
-  await fs.writeFile(path.join(root, ".env"), content);
-};

packages/create-llama/helpers/index.ts

@@ -1,242 +0,0 @@
-import { callPackageManager } from "./install";
-
-import path from "path";
-import picocolors, { cyan } from "picocolors";
-
-import fsExtra from "fs-extra";
-import { writeLoadersConfig } from "./datasources";
-import { createBackendEnvFile, createFrontendEnvFile } from "./env-variables";
-import { PackageManager } from "./get-pkg-manager";
-import { installLlamapackProject } from "./llama-pack";
-import { makeDir } from "./make-dir";
-import { installPythonTemplate } from "./python";
-import { downloadAndExtractRepo } from "./repo";
-import { ConfigFileType, writeToolsConfig } from "./tools";
-import {
-  FileSourceConfig,
-  InstallTemplateArgs,
-  ModelConfig,
-  TemplateDataSource,
-  TemplateFramework,
-  TemplateVectorDB,
-} from "./types";
-import { installTSTemplate } from "./typescript";
-import { isHavingUvLockFile, tryUvRun } from "./uv";
-
-const checkForGenerateScript = (
-  modelConfig: ModelConfig,
-  vectorDb?: TemplateVectorDB,
-  llamaCloudKey?: string,
-  useLlamaParse?: boolean,
-) => {
-  const missingSettings = [];
-
-  if (!modelConfig.isConfigured()) {
-    missingSettings.push("your model provider API key");
-  }
-
-  const llamaCloudApiKey = llamaCloudKey ?? process.env["LLAMA_CLOUD_API_KEY"];
-  const isRequiredLlamaCloudKey = useLlamaParse || vectorDb === "llamacloud";
-  if (isRequiredLlamaCloudKey && !llamaCloudApiKey) {
-    missingSettings.push("your LLAMA_CLOUD_API_KEY");
-  }
-
-  if (
-    vectorDb !== undefined &&
-    vectorDb !== "none" &&
-    vectorDb !== "llamacloud"
-  ) {
-    missingSettings.push("your Vector DB environment variables");
-  }
-
-  return missingSettings;
-};
-
-// eslint-disable-next-line max-params
-async function generateContextData(
-  framework: TemplateFramework,
-  modelConfig: ModelConfig,
-  packageManager?: PackageManager,
-  vectorDb?: TemplateVectorDB,
-  llamaCloudKey?: string,
-  useLlamaParse?: boolean,
-) {
-  if (packageManager) {
-    const runGenerate = `${cyan(
-      framework === "fastapi"
-        ? "uv run generate"
-        : `${packageManager} run generate`,
-    )}`;
-
-    const missingSettings = checkForGenerateScript(
-      modelConfig,
-      vectorDb,
-      llamaCloudKey,
-      useLlamaParse,
-    );
-
-    if (!missingSettings.length) {
-      // If all the required environment variables are set, run the generate script
-      if (framework === "fastapi") {
-        if (isHavingUvLockFile()) {
-          console.log(`Running ${runGenerate} to generate the context data.`);
-          const result = tryUvRun("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.`);
-        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`));
-  }
-}
-
-const downloadFile = async (url: string, destPath: string) => {
-  const response = await fetch(url);
-  const fileBuffer = await response.arrayBuffer();
-  await fsExtra.writeFile(destPath, new Uint8Array(fileBuffer));
-};
-
-const prepareContextData = async (
-  root: string,
-  dataSources: TemplateDataSource[],
-) => {
-  await makeDir(path.join(root, "data"));
-  for (const dataSource of dataSources) {
-    const dataSourceConfig = dataSource?.config as FileSourceConfig;
-    // If the path is URLs, download the data and save it to the data directory
-    if ("url" in dataSourceConfig) {
-      console.log(
-        "Downloading file from URL:",
-        dataSourceConfig.url.toString(),
-      );
-      const destPath = path.join(
-        root,
-        "data",
-        dataSourceConfig.filename ??
-          path.basename(dataSourceConfig.url.toString()),
-      );
-      await downloadFile(dataSourceConfig.url.toString(), destPath);
-    } else {
-      // Copy local data
-      console.log("Copying data from path:", dataSourceConfig.path);
-      const destPath = path.join(
-        root,
-        "data",
-        path.basename(dataSourceConfig.path),
-      );
-      await fsExtra.copy(dataSourceConfig.path, destPath);
-    }
-  }
-};
-
-const installCommunityProject = async ({
-  root,
-  communityProjectConfig,
-}: Pick<InstallTemplateArgs, "root" | "communityProjectConfig">) => {
-  const { owner, repo, branch, filePath } = communityProjectConfig!;
-  console.log("\nInstalling community project:", filePath || repo);
-  await downloadAndExtractRepo(root, {
-    username: owner,
-    name: repo,
-    branch,
-    filePath: filePath || "",
-  });
-};
-
-export const installTemplate = async (
-  props: InstallTemplateArgs & { backend: boolean },
-) => {
-  process.chdir(props.root);
-
-  if (props.template === "community" && props.communityProjectConfig) {
-    await installCommunityProject(props);
-    return;
-  }
-
-  if (props.template === "llamapack" && props.llamapack) {
-    await installLlamapackProject(props);
-    return;
-  }
-
-  if (props.framework === "fastapi") {
-    await installPythonTemplate(props);
-  } else {
-    await installTSTemplate(props);
-  }
-
-  // write configurations
-  if (props.template !== "llamaindexserver") {
-    await writeToolsConfig(
-      props.root,
-      props.tools,
-      props.framework === "fastapi" ? ConfigFileType.YAML : ConfigFileType.JSON,
-    );
-    if (props.vectorDb !== "llamacloud") {
-      // write loaders configuration (currently Python only)
-      // not needed for LlamaCloud as it has its own loaders
-      await writeLoadersConfig(
-        props.root,
-        props.dataSources,
-        props.useLlamaParse,
-      );
-    }
-  }
-
-  if (props.backend) {
-    // This is a backend, so we need to copy the test data and create the env file.
-
-    // Copy the environment file to the target directory.
-    if (props.template !== "community" && props.template !== "llamapack") {
-      await createBackendEnvFile(props.root, props);
-    }
-
-    await prepareContextData(
-      props.root,
-      props.dataSources.filter((ds) => ds.type === "file"),
-    );
-
-    if (
-      props.dataSources.length > 0 &&
-      (props.postInstallAction === "runApp" ||
-        props.postInstallAction === "dependencies")
-    ) {
-      console.log("\nGenerating context data...\n");
-      await generateContextData(
-        props.framework,
-        props.modelConfig,
-        props.packageManager,
-        props.vectorDb,
-        props.llamaCloudKey,
-        props.useLlamaParse,
-      );
-    }
-
-    // Create outputs directory
-    await makeDir(path.join(props.root, "output/tools"));
-    await makeDir(path.join(props.root, "output/uploaded"));
-    await makeDir(path.join(props.root, "output/llamacloud"));
-  } else {
-    // this is a frontend for a full-stack app, create .env file with model information
-    await createFrontendEnvFile(props.root, {
-      vectorDb: props.vectorDb,
-    });
-  }
-};
-
-export * from "./types";

packages/create-llama/helpers/providers/anthropic.ts

@@ -1,103 +0,0 @@
-import prompts from "prompts";
-import { ModelConfigParams } from ".";
-import { questionHandlers, toChoice } from "../../questions/utils";
-
-const MODELS = [
-  "claude-3-opus",
-  "claude-3-sonnet",
-  "claude-3-haiku",
-  "claude-2.1",
-  "claude-instant-1.2",
-];
-const DEFAULT_MODEL = MODELS[0];
-
-// TODO: get embedding vector dimensions from the anthropic sdk (currently not supported)
-// Use huggingface embedding models for now
-enum HuggingFaceEmbeddingModelType {
-  XENOVA_ALL_MINILM_L6_V2 = "all-MiniLM-L6-v2",
-  XENOVA_ALL_MPNET_BASE_V2 = "all-mpnet-base-v2",
-}
-type ModelData = {
-  dimensions: number;
-};
-const EMBEDDING_MODELS: Record<HuggingFaceEmbeddingModelType, ModelData> = {
-  [HuggingFaceEmbeddingModelType.XENOVA_ALL_MINILM_L6_V2]: {
-    dimensions: 384,
-  },
-  [HuggingFaceEmbeddingModelType.XENOVA_ALL_MPNET_BASE_V2]: {
-    dimensions: 768,
-  },
-};
-const DEFAULT_EMBEDDING_MODEL = Object.keys(EMBEDDING_MODELS)[0];
-const DEFAULT_DIMENSIONS = Object.values(EMBEDDING_MODELS)[0].dimensions;
-
-type AnthropicQuestionsParams = {
-  apiKey?: string;
-  askModels: boolean;
-};
-
-export async function askAnthropicQuestions({
-  askModels,
-  apiKey,
-}: AnthropicQuestionsParams): Promise<ModelConfigParams> {
-  const config: ModelConfigParams = {
-    apiKey,
-    model: DEFAULT_MODEL,
-    embeddingModel: DEFAULT_EMBEDDING_MODEL,
-    dimensions: DEFAULT_DIMENSIONS,
-    isConfigured(): boolean {
-      if (config.apiKey) {
-        return true;
-      }
-      if (process.env["ANTHROPIC_API_KEY"]) {
-        return true;
-      }
-      return false;
-    },
-  };
-
-  if (!config.apiKey) {
-    const { key } = await prompts(
-      {
-        type: "text",
-        name: "key",
-        message:
-          "Please provide your Anthropic API key (or leave blank to use ANTHROPIC_API_KEY env variable):",
-      },
-      questionHandlers,
-    );
-    config.apiKey = key || process.env.ANTHROPIC_API_KEY;
-  }
-
-  if (askModels) {
-    const { model } = await prompts(
-      {
-        type: "select",
-        name: "model",
-        message: "Which LLM model would you like to use?",
-        choices: MODELS.map(toChoice),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.model = model;
-
-    const { embeddingModel } = await prompts(
-      {
-        type: "select",
-        name: "embeddingModel",
-        message: "Which embedding model would you like to use?",
-        choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.embeddingModel = embeddingModel;
-    config.dimensions =
-      EMBEDDING_MODELS[
-        embeddingModel as HuggingFaceEmbeddingModelType
-      ].dimensions;
-  }
-
-  return config;
-}

packages/create-llama/helpers/providers/azure.ts

@@ -1,115 +0,0 @@
-import prompts from "prompts";
-import { ModelConfigParams, ModelConfigQuestionsParams } from ".";
-import { questionHandlers } from "../../questions/utils";
-
-const ALL_AZURE_OPENAI_CHAT_MODELS: Record<string, { openAIModel: string }> = {
-  "gpt-35-turbo": { openAIModel: "gpt-3.5-turbo" },
-  "gpt-35-turbo-16k": {
-    openAIModel: "gpt-3.5-turbo-16k",
-  },
-  "gpt-4o": { openAIModel: "gpt-4o" },
-  "gpt-4o-mini": { openAIModel: "gpt-4o-mini" },
-  "gpt-4": { openAIModel: "gpt-4" },
-  "gpt-4-32k": { openAIModel: "gpt-4-32k" },
-  "gpt-4-turbo": {
-    openAIModel: "gpt-4-turbo",
-  },
-  "gpt-4-turbo-2024-04-09": {
-    openAIModel: "gpt-4-turbo",
-  },
-  "gpt-4-vision-preview": {
-    openAIModel: "gpt-4-vision-preview",
-  },
-  "gpt-4-1106-preview": {
-    openAIModel: "gpt-4-1106-preview",
-  },
-  "gpt-4o-2024-05-13": {
-    openAIModel: "gpt-4o-2024-05-13",
-  },
-  "gpt-4o-mini-2024-07-18": {
-    openAIModel: "gpt-4o-mini-2024-07-18",
-  },
-};
-
-const ALL_AZURE_OPENAI_EMBEDDING_MODELS: Record<
-  string,
-  {
-    dimensions: number;
-    openAIModel: string;
-  }
-> = {
-  "text-embedding-3-small": {
-    dimensions: 1536,
-    openAIModel: "text-embedding-3-small",
-  },
-  "text-embedding-3-large": {
-    dimensions: 3072,
-    openAIModel: "text-embedding-3-large",
-  },
-};
-
-const DEFAULT_MODEL = "gpt-4o";
-const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-large";
-
-export async function askAzureQuestions({
-  openAiKey,
-  askModels,
-}: ModelConfigQuestionsParams): Promise<ModelConfigParams> {
-  const config: ModelConfigParams = {
-    apiKey: openAiKey || process.env.AZURE_OPENAI_KEY,
-    model: DEFAULT_MODEL,
-    embeddingModel: DEFAULT_EMBEDDING_MODEL,
-    dimensions: getDimensions(DEFAULT_EMBEDDING_MODEL),
-    isConfigured(): boolean {
-      // the Azure model provider can't be fully configured as endpoint and deployment names have to be configured with env variables
-      return false;
-    },
-  };
-
-  if (askModels) {
-    const { model } = await prompts(
-      {
-        type: "select",
-        name: "model",
-        message: "Which LLM model would you like to use?",
-        choices: getAvailableModelChoices(),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.model = model;
-
-    const { embeddingModel } = await prompts(
-      {
-        type: "select",
-        name: "embeddingModel",
-        message: "Which embedding model would you like to use?",
-        choices: getAvailableEmbeddingModelChoices(),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.embeddingModel = embeddingModel;
-    config.dimensions = getDimensions(embeddingModel);
-  }
-
-  return config;
-}
-
-function getAvailableModelChoices() {
-  return Object.keys(ALL_AZURE_OPENAI_CHAT_MODELS).map((key) => ({
-    title: key,
-    value: key,
-  }));
-}
-
-function getAvailableEmbeddingModelChoices() {
-  return Object.keys(ALL_AZURE_OPENAI_EMBEDDING_MODELS).map((key) => ({
-    title: key,
-    value: key,
-  }));
-}
-
-function getDimensions(modelName: string) {
-  return ALL_AZURE_OPENAI_EMBEDDING_MODELS[modelName].dimensions;
-}

packages/create-llama/helpers/providers/gemini.ts

@@ -1,84 +0,0 @@
-import prompts from "prompts";
-import { ModelConfigParams } from ".";
-import { questionHandlers, toChoice } from "../../questions/utils";
-
-const MODELS = ["gemini-1.5-pro-latest", "gemini-pro", "gemini-pro-vision"];
-type ModelData = {
-  dimensions: number;
-};
-const EMBEDDING_MODELS: Record<string, ModelData> = {
-  "embedding-001": { dimensions: 768 },
-  "text-embedding-004": { dimensions: 768 },
-};
-
-const DEFAULT_MODEL = MODELS[0];
-const DEFAULT_EMBEDDING_MODEL = Object.keys(EMBEDDING_MODELS)[0];
-const DEFAULT_DIMENSIONS = Object.values(EMBEDDING_MODELS)[0].dimensions;
-
-type GeminiQuestionsParams = {
-  apiKey?: string;
-  askModels: boolean;
-};
-
-export async function askGeminiQuestions({
-  askModels,
-  apiKey,
-}: GeminiQuestionsParams): Promise<ModelConfigParams> {
-  const config: ModelConfigParams = {
-    apiKey,
-    model: DEFAULT_MODEL,
-    embeddingModel: DEFAULT_EMBEDDING_MODEL,
-    dimensions: DEFAULT_DIMENSIONS,
-    isConfigured(): boolean {
-      if (config.apiKey) {
-        return true;
-      }
-      if (process.env["GOOGLE_API_KEY"]) {
-        return true;
-      }
-      return false;
-    },
-  };
-
-  if (!config.apiKey) {
-    const { key } = await prompts(
-      {
-        type: "text",
-        name: "key",
-        message:
-          "Please provide your Google API key (or leave blank to use GOOGLE_API_KEY env variable):",
-      },
-      questionHandlers,
-    );
-    config.apiKey = key || process.env.GOOGLE_API_KEY;
-  }
-
-  if (askModels) {
-    const { model } = await prompts(
-      {
-        type: "select",
-        name: "model",
-        message: "Which LLM model would you like to use?",
-        choices: MODELS.map(toChoice),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.model = model;
-
-    const { embeddingModel } = await prompts(
-      {
-        type: "select",
-        name: "embeddingModel",
-        message: "Which embedding model would you like to use?",
-        choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.embeddingModel = embeddingModel;
-    config.dimensions = EMBEDDING_MODELS[embeddingModel].dimensions;
-  }
-
-  return config;
-}

packages/create-llama/helpers/providers/groq.ts

@@ -1,145 +0,0 @@
-import prompts from "prompts";
-import { ModelConfigParams } from ".";
-import { questionHandlers, toChoice } from "../../questions/utils";
-
-import got from "got";
-import ora from "ora";
-import { red } from "picocolors";
-
-const GROQ_API_URL = "https://api.groq.com/openai/v1";
-
-async function getAvailableModelChoicesGroq(apiKey: string) {
-  if (!apiKey) {
-    throw new Error("Need Groq API key to retrieve model choices");
-  }
-
-  const spinner = ora("Fetching available models from Groq").start();
-  try {
-    const response = await got(`${GROQ_API_URL}/models`, {
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-      },
-      timeout: 5000,
-      responseType: "json",
-    });
-    const data: any = await response.body;
-    spinner.stop();
-
-    // Filter out the Whisper models
-    return data.data
-      .filter((model: any) => !model.id.toLowerCase().includes("whisper"))
-      .map((el: any) => {
-        return {
-          title: el.id,
-          value: el.id,
-        };
-      });
-  } catch (error: unknown) {
-    spinner.stop();
-    console.log(error);
-    if ((error as any).response?.statusCode === 401) {
-      console.log(
-        red(
-          "Invalid Groq API key provided! Please provide a valid key and try again!",
-        ),
-      );
-    } else {
-      console.log(red("Request failed: " + error));
-    }
-    process.exit(1);
-  }
-}
-
-const DEFAULT_MODEL = "llama3-70b-8192";
-
-// Use huggingface embedding models for now as Groq doesn't support embedding models
-enum HuggingFaceEmbeddingModelType {
-  XENOVA_ALL_MINILM_L6_V2 = "all-MiniLM-L6-v2",
-  XENOVA_ALL_MPNET_BASE_V2 = "all-mpnet-base-v2",
-}
-type ModelData = {
-  dimensions: number;
-};
-const EMBEDDING_MODELS: Record<HuggingFaceEmbeddingModelType, ModelData> = {
-  [HuggingFaceEmbeddingModelType.XENOVA_ALL_MINILM_L6_V2]: {
-    dimensions: 384,
-  },
-  [HuggingFaceEmbeddingModelType.XENOVA_ALL_MPNET_BASE_V2]: {
-    dimensions: 768,
-  },
-};
-const DEFAULT_EMBEDDING_MODEL = Object.keys(EMBEDDING_MODELS)[0];
-const DEFAULT_DIMENSIONS = Object.values(EMBEDDING_MODELS)[0].dimensions;
-
-type GroqQuestionsParams = {
-  apiKey?: string;
-  askModels: boolean;
-};
-
-export async function askGroqQuestions({
-  askModels,
-  apiKey,
-}: GroqQuestionsParams): Promise<ModelConfigParams> {
-  const config: ModelConfigParams = {
-    apiKey,
-    model: DEFAULT_MODEL,
-    embeddingModel: DEFAULT_EMBEDDING_MODEL,
-    dimensions: DEFAULT_DIMENSIONS,
-    isConfigured(): boolean {
-      if (config.apiKey) {
-        return true;
-      }
-      if (process.env["GROQ_API_KEY"]) {
-        return true;
-      }
-      return false;
-    },
-  };
-
-  if (!config.apiKey) {
-    const { key } = await prompts(
-      {
-        type: "text",
-        name: "key",
-        message:
-          "Please provide your Groq API key (or leave blank to use GROQ_API_KEY env variable):",
-      },
-      questionHandlers,
-    );
-    config.apiKey = key || process.env.GROQ_API_KEY;
-  }
-
-  if (askModels) {
-    const modelChoices = await getAvailableModelChoicesGroq(config.apiKey!);
-
-    const { model } = await prompts(
-      {
-        type: "select",
-        name: "model",
-        message: "Which LLM model would you like to use?",
-        choices: modelChoices,
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.model = model;
-
-    const { embeddingModel } = await prompts(
-      {
-        type: "select",
-        name: "embeddingModel",
-        message: "Which embedding model would you like to use?",
-        choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.embeddingModel = embeddingModel;
-    config.dimensions =
-      EMBEDDING_MODELS[
-        embeddingModel as HuggingFaceEmbeddingModelType
-      ].dimensions;
-  }
-
-  return config;
-}

packages/create-llama/helpers/providers/huggingface.ts

@@ -1,68 +0,0 @@
-import prompts from "prompts";
-import { ModelConfigParams } from ".";
-import { questionHandlers, toChoice } from "../../questions/utils";
-
-const MODELS = ["HuggingFaceH4/zephyr-7b-alpha"];
-type ModelData = {
-  dimensions: number;
-};
-const EMBEDDING_MODELS: Record<string, ModelData> = {
-  "BAAI/bge-small-en-v1.5": { dimensions: 384 },
-  "BAAI/bge-base-en-v1.5": { dimensions: 768 },
-  "BAAI/bge-large-en-v1.5": { dimensions: 1024 },
-  "sentence-transformers/all-MiniLM-L6-v2": { dimensions: 384 },
-  "sentence-transformers/all-mpnet-base-v2": { dimensions: 768 },
-  "intfloat/multilingual-e5-large": { dimensions: 1024 },
-  "mixedbread-ai/mxbai-embed-large-v1": { dimensions: 1024 },
-  "nomic-ai/nomic-embed-text-v1.5": { dimensions: 768 },
-};
-
-const DEFAULT_MODEL = MODELS[0];
-const DEFAULT_EMBEDDING_MODEL = Object.keys(EMBEDDING_MODELS)[0];
-const DEFAULT_DIMENSIONS = Object.values(EMBEDDING_MODELS)[0].dimensions;
-
-type HuggingfaceQuestionsParams = {
-  askModels: boolean;
-};
-
-export async function askHuggingfaceQuestions({
-  askModels,
-}: HuggingfaceQuestionsParams): Promise<ModelConfigParams> {
-  const config: ModelConfigParams = {
-    model: DEFAULT_MODEL,
-    embeddingModel: DEFAULT_EMBEDDING_MODEL,
-    dimensions: DEFAULT_DIMENSIONS,
-    isConfigured(): boolean {
-      return true;
-    },
-  };
-
-  if (askModels) {
-    const { model } = await prompts(
-      {
-        type: "select",
-        name: "model",
-        message: "Which Hugging Face model would you like to use?",
-        choices: MODELS.map(toChoice),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.model = model;
-
-    const { embeddingModel } = await prompts(
-      {
-        type: "select",
-        name: "embeddingModel",
-        message: "Which embedding model would you like to use?",
-        choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.embeddingModel = embeddingModel;
-    config.dimensions = EMBEDDING_MODELS[embeddingModel].dimensions;
-  }
-
-  return config;
-}

packages/create-llama/helpers/providers/index.ts

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

packages/create-llama/helpers/providers/llmhub.ts

@@ -1,166 +0,0 @@
-import got from "got";
-import ora from "ora";
-import { red } from "picocolors";
-import prompts from "prompts";
-import { ModelConfigParams } from ".";
-import { questionHandlers } from "../../questions/utils";
-
-export const TSYSTEMS_LLMHUB_API_URL =
-  "https://llm-server.llmhub.t-systems.net/v2";
-
-const DEFAULT_MODEL = "gpt-3.5-turbo";
-const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-large";
-
-const LLMHUB_MODELS = [
-  "gpt-35-turbo",
-  "gpt-4-32k-1",
-  "gpt-4-32k-canada",
-  "gpt-4-32k-france",
-  "gpt-4-turbo-128k-france",
-  "Llama2-70b-Instruct",
-  "Llama-3-70B-Instruct",
-  "Mixtral-8x7B-Instruct-v0.1",
-  "mistral-large-32k-france",
-  "CodeLlama-2",
-];
-const LLMHUB_EMBEDDING_MODELS = [
-  "text-embedding-ada-002",
-  "text-embedding-ada-002-france",
-  "jina-embeddings-v2-base-de",
-  "jina-embeddings-v2-base-code",
-  "text-embedding-bge-m3",
-];
-
-type LLMHubQuestionsParams = {
-  apiKey?: string;
-  askModels: boolean;
-};
-
-export async function askLLMHubQuestions({
-  askModels,
-  apiKey,
-}: LLMHubQuestionsParams): Promise<ModelConfigParams> {
-  const config: ModelConfigParams = {
-    apiKey,
-    model: DEFAULT_MODEL,
-    embeddingModel: DEFAULT_EMBEDDING_MODEL,
-    dimensions: getDimensions(DEFAULT_EMBEDDING_MODEL),
-    isConfigured(): boolean {
-      if (config.apiKey) {
-        return true;
-      }
-      if (process.env["T_SYSTEMS_LLMHUB_API_KEY"]) {
-        return true;
-      }
-      return false;
-    },
-  };
-
-  if (!config.apiKey) {
-    const { key } = await prompts(
-      {
-        type: "text",
-        name: "key",
-        message: askModels
-          ? "Please provide your LLMHub API key (or leave blank to use T_SYSTEMS_LLMHUB_API_KEY env variable):"
-          : "Please provide your LLMHub API key (leave blank to skip):",
-        validate: (value: string) => {
-          if (askModels && !value) {
-            if (process.env.T_SYSTEMS_LLMHUB_API_KEY) {
-              return true;
-            }
-            return "T_SYSTEMS_LLMHUB_API_KEY env variable is not set - key is required";
-          }
-          return true;
-        },
-      },
-      questionHandlers,
-    );
-    config.apiKey = key || process.env.T_SYSTEMS_LLMHUB_API_KEY;
-  }
-
-  if (askModels) {
-    const { model } = await prompts(
-      {
-        type: "select",
-        name: "model",
-        message: "Which LLM model would you like to use?",
-        choices: await getAvailableModelChoices(false, config.apiKey),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.model = model;
-
-    const { embeddingModel } = await prompts(
-      {
-        type: "select",
-        name: "embeddingModel",
-        message: "Which embedding model would you like to use?",
-        choices: await getAvailableModelChoices(true, config.apiKey),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.embeddingModel = embeddingModel;
-    config.dimensions = getDimensions(embeddingModel);
-  }
-
-  return config;
-}
-
-async function getAvailableModelChoices(
-  selectEmbedding: boolean,
-  apiKey?: string,
-) {
-  if (!apiKey) {
-    throw new Error("Need LLMHub key to retrieve model choices");
-  }
-  const isLLMModel = (modelId: string) => {
-    return LLMHUB_MODELS.includes(modelId);
-  };
-
-  const isEmbeddingModel = (modelId: string) => {
-    return LLMHUB_EMBEDDING_MODELS.includes(modelId);
-  };
-
-  const spinner = ora("Fetching available models").start();
-  try {
-    const response = await got(`${TSYSTEMS_LLMHUB_API_URL}/models`, {
-      headers: {
-        Authorization: "Bearer " + apiKey,
-      },
-      timeout: 5000,
-      responseType: "json",
-    });
-    const data: any = await response.body;
-    spinner.stop();
-    return data.data
-      .filter((model: any) =>
-        selectEmbedding ? isEmbeddingModel(model.id) : isLLMModel(model.id),
-      )
-      .map((el: any) => {
-        return {
-          title: el.id,
-          value: el.id,
-        };
-      });
-  } catch (error) {
-    spinner.stop();
-    if ((error as any).response?.statusCode === 401) {
-      console.log(
-        red(
-          "Invalid LLMHub API key provided! Please provide a valid key and try again!",
-        ),
-      );
-    } else {
-      console.log(red("Request failed: " + error));
-    }
-    process.exit(1);
-  }
-}
-
-function getDimensions(modelName: string) {
-  // Assuming dimensions similar to OpenAI for simplicity. Update if different.
-  return modelName === "text-embedding-004" ? 768 : 1536;
-}

packages/create-llama/helpers/providers/mistral.ts

@@ -1,83 +0,0 @@
-import prompts from "prompts";
-import { ModelConfigParams } from ".";
-import { questionHandlers, toChoice } from "../../questions/utils";
-
-const MODELS = ["mistral-tiny", "mistral-small", "mistral-medium"];
-type ModelData = {
-  dimensions: number;
-};
-const EMBEDDING_MODELS: Record<string, ModelData> = {
-  "mistral-embed": { dimensions: 1024 },
-};
-
-const DEFAULT_MODEL = MODELS[0];
-const DEFAULT_EMBEDDING_MODEL = Object.keys(EMBEDDING_MODELS)[0];
-const DEFAULT_DIMENSIONS = Object.values(EMBEDDING_MODELS)[0].dimensions;
-
-type MistralQuestionsParams = {
-  apiKey?: string;
-  askModels: boolean;
-};
-
-export async function askMistralQuestions({
-  askModels,
-  apiKey,
-}: MistralQuestionsParams): Promise<ModelConfigParams> {
-  const config: ModelConfigParams = {
-    apiKey,
-    model: DEFAULT_MODEL,
-    embeddingModel: DEFAULT_EMBEDDING_MODEL,
-    dimensions: DEFAULT_DIMENSIONS,
-    isConfigured(): boolean {
-      if (config.apiKey) {
-        return true;
-      }
-      if (process.env["MISTRAL_API_KEY"]) {
-        return true;
-      }
-      return false;
-    },
-  };
-
-  if (!config.apiKey) {
-    const { key } = await prompts(
-      {
-        type: "text",
-        name: "key",
-        message:
-          "Please provide your Mistral API key (or leave blank to use MISTRAL_API_KEY env variable):",
-      },
-      questionHandlers,
-    );
-    config.apiKey = key || process.env.MISTRAL_API_KEY;
-  }
-
-  if (askModels) {
-    const { model } = await prompts(
-      {
-        type: "select",
-        name: "model",
-        message: "Which LLM model would you like to use?",
-        choices: MODELS.map(toChoice),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.model = model;
-
-    const { embeddingModel } = await prompts(
-      {
-        type: "select",
-        name: "embeddingModel",
-        message: "Which embedding model would you like to use?",
-        choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.embeddingModel = embeddingModel;
-    config.dimensions = EMBEDDING_MODELS[embeddingModel].dimensions;
-  }
-
-  return config;
-}

packages/create-llama/helpers/providers/ollama.ts

@@ -1,92 +0,0 @@
-import ollama, { type ModelResponse } from "ollama";
-import { red } from "picocolors";
-import prompts from "prompts";
-import { ModelConfigParams } from ".";
-import { questionHandlers, toChoice } from "../../questions/utils";
-
-type ModelData = {
-  dimensions: number;
-};
-const MODELS = ["llama3:8b", "wizardlm2:7b", "gemma:7b", "phi3"];
-const DEFAULT_MODEL = MODELS[0];
-// TODO: get embedding vector dimensions from the ollama sdk (currently not supported)
-const EMBEDDING_MODELS: Record<string, ModelData> = {
-  "nomic-embed-text": { dimensions: 768 },
-  "mxbai-embed-large": { dimensions: 1024 },
-  "all-minilm": { dimensions: 384 },
-};
-const DEFAULT_EMBEDDING_MODEL: string = Object.keys(EMBEDDING_MODELS)[0];
-
-type OllamaQuestionsParams = {
-  askModels: boolean;
-};
-
-export async function askOllamaQuestions({
-  askModels,
-}: OllamaQuestionsParams): Promise<ModelConfigParams> {
-  const config: ModelConfigParams = {
-    model: DEFAULT_MODEL,
-    embeddingModel: DEFAULT_EMBEDDING_MODEL,
-    dimensions: EMBEDDING_MODELS[DEFAULT_EMBEDDING_MODEL].dimensions,
-    isConfigured(): boolean {
-      return true;
-    },
-  };
-
-  if (askModels) {
-    const { model } = await prompts(
-      {
-        type: "select",
-        name: "model",
-        message: "Which LLM model would you like to use?",
-        choices: MODELS.map(toChoice),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    await ensureModel(model);
-    config.model = model;
-
-    const { embeddingModel } = await prompts(
-      {
-        type: "select",
-        name: "embeddingModel",
-        message: "Which embedding model would you like to use?",
-        choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    await ensureModel(embeddingModel);
-    config.embeddingModel = embeddingModel;
-    config.dimensions = EMBEDDING_MODELS[embeddingModel].dimensions;
-  }
-
-  return config;
-}
-
-async function ensureModel(modelName: string) {
-  try {
-    if (modelName.split(":").length === 1) {
-      // model doesn't have a version suffix, use latest
-      modelName = modelName + ":latest";
-    }
-    const { models } = await ollama.list();
-    const found =
-      models.find((model: ModelResponse) => model.name === modelName) !==
-      undefined;
-    if (!found) {
-      console.log(
-        red(
-          `Model ${modelName} was not pulled yet. Call 'ollama pull ${modelName}' and try again.`,
-        ),
-      );
-      process.exit(1);
-    }
-  } catch (error) {
-    console.log(
-      red("Listing Ollama models failed. Is 'ollama' running? " + error),
-    );
-    process.exit(1);
-  }
-}

packages/create-llama/helpers/providers/openai.ts

@@ -1,142 +0,0 @@
-import got from "got";
-import ora from "ora";
-import { red } from "picocolors";
-import prompts from "prompts";
-import { ModelConfigParams, ModelConfigQuestionsParams } from ".";
-import { isCI } from "../../questions";
-import { questionHandlers } from "../../questions/utils";
-
-const OPENAI_API_URL = "https://api.openai.com/v1";
-
-const DEFAULT_MODEL = "gpt-4o-mini";
-const DEFAULT_EMBEDDING_MODEL = "text-embedding-3-large";
-
-export async function askOpenAIQuestions({
-  openAiKey,
-  askModels,
-}: ModelConfigQuestionsParams): Promise<ModelConfigParams> {
-  const config: ModelConfigParams = {
-    apiKey: openAiKey,
-    model: DEFAULT_MODEL,
-    embeddingModel: DEFAULT_EMBEDDING_MODEL,
-    dimensions: getDimensions(DEFAULT_EMBEDDING_MODEL),
-    isConfigured(): boolean {
-      if (config.apiKey) {
-        return true;
-      }
-      if (process.env["OPENAI_API_KEY"]) {
-        return true;
-      }
-      return false;
-    },
-  };
-
-  if (!config.apiKey && !isCI) {
-    const { key } = await prompts(
-      {
-        type: "text",
-        name: "key",
-        message: askModels
-          ? "Please provide your OpenAI API key (or leave blank to use OPENAI_API_KEY env variable):"
-          : "Please provide your OpenAI API key (leave blank to skip):",
-        validate: (value: string) => {
-          if (askModels && !value) {
-            if (process.env.OPENAI_API_KEY) {
-              return true;
-            }
-            return "OPENAI_API_KEY env variable is not set - key is required";
-          }
-          return true;
-        },
-      },
-      questionHandlers,
-    );
-    config.apiKey = key || process.env.OPENAI_API_KEY;
-  }
-
-  if (askModels) {
-    const { model } = await prompts(
-      {
-        type: "select",
-        name: "model",
-        message: "Which LLM model would you like to use?",
-        choices: await getAvailableModelChoices(false, config.apiKey),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.model = model;
-
-    const { embeddingModel } = await prompts(
-      {
-        type: "select",
-        name: "embeddingModel",
-        message: "Which embedding model would you like to use?",
-        choices: await getAvailableModelChoices(true, config.apiKey),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.embeddingModel = embeddingModel;
-    config.dimensions = getDimensions(embeddingModel);
-  }
-
-  return config;
-}
-
-async function getAvailableModelChoices(
-  selectEmbedding: boolean,
-  apiKey?: string,
-) {
-  if (!apiKey) {
-    throw new Error("need OpenAI key to retrieve model choices");
-  }
-  const isLLMModel = (modelId: string) => {
-    return modelId.startsWith("gpt");
-  };
-
-  const isEmbeddingModel = (modelId: string) => {
-    return modelId.includes("embedding");
-  };
-
-  const spinner = ora("Fetching available models").start();
-  try {
-    const response = await got(`${OPENAI_API_URL}/models`, {
-      headers: {
-        Authorization: "Bearer " + apiKey,
-      },
-      timeout: 5000,
-      responseType: "json",
-    });
-    const data: any = await response.body;
-    spinner.stop();
-    return data.data
-      .filter((model: any) =>
-        selectEmbedding ? isEmbeddingModel(model.id) : isLLMModel(model.id),
-      )
-      .map((el: any) => {
-        return {
-          title: el.id,
-          value: el.id,
-        };
-      });
-  } catch (error) {
-    spinner.stop();
-    if ((error as any).response?.statusCode === 401) {
-      console.log(
-        red(
-          "Invalid OpenAI API key provided! Please provide a valid key and try again!",
-        ),
-      );
-    } else {
-      console.log(red("Request failed: " + error));
-    }
-    process.exit(1);
-  }
-}
-
-function getDimensions(modelName: string) {
-  // at 2024-04-24 all OpenAI embedding models support 1536 dimensions except
-  // "text-embedding-3-large", see https://openai.com/blog/new-embedding-models-and-api-updates
-  return modelName === "text-embedding-3-large" ? 1024 : 1536;
-}

packages/create-llama/helpers/proxy.ts

@@ -1,8 +0,0 @@
-/* Function to conditionally load the global-agent/bootstrap module */
-export async function initializeGlobalAgent() {
-  if (process.env.GLOBAL_AGENT_HTTP_PROXY) {
-    /* Dynamically import global-agent/bootstrap */
-    await import("global-agent/bootstrap");
-    console.log("Proxy enabled via global-agent.");
-  }
-}

packages/create-llama/helpers/python.ts

@@ -1,682 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-import { cyan, red } from "picocolors";
-import { parse, stringify } from "smol-toml";
-import terminalLink from "terminal-link";
-import { isUvAvailable, tryUvSync } from "./uv";
-
-import { assetRelocator, copy } from "./copy";
-import { templatesDir } from "./dir";
-import { Tool } from "./tools";
-import {
-  InstallTemplateArgs,
-  ModelConfig,
-  TemplateDataSource,
-  TemplateObservability,
-  TemplateType,
-  TemplateVectorDB,
-} from "./types";
-
-interface Dependency {
-  name: string;
-  version?: string;
-  extras?: string[];
-  constraints?: Record<string, string>;
-}
-
-const getAdditionalDependencies = (
-  modelConfig: ModelConfig,
-  vectorDb?: TemplateVectorDB,
-  dataSources?: TemplateDataSource[],
-  tools?: Tool[],
-  templateType?: TemplateType,
-  observability?: TemplateObservability,
-) => {
-  const dependencies: Dependency[] = [];
-
-  // Add vector db dependencies
-  switch (vectorDb) {
-    case "mongo": {
-      dependencies.push({
-        name: "llama-index-vector-stores-mongodb",
-        version: ">=0.3.2,<0.4.0",
-      });
-      break;
-    }
-    case "pg": {
-      dependencies.push({
-        name: "llama-index-vector-stores-postgres",
-        version: ">=0.3.2,<0.4.0",
-      });
-      break;
-    }
-    case "pinecone": {
-      dependencies.push({
-        name: "llama-index-vector-stores-pinecone",
-        version: ">=0.4.1,<0.5.0",
-        constraints: {
-          python: ">=3.11,<3.13",
-        },
-      });
-      break;
-    }
-    case "milvus": {
-      dependencies.push({
-        name: "llama-index-vector-stores-milvus",
-        version: ">=0.3.0,<0.4.0",
-      });
-      dependencies.push({
-        name: "pymilvus",
-        version: ">=2.4.4,<3.0.0",
-      });
-      break;
-    }
-    case "astra": {
-      dependencies.push({
-        name: "llama-index-vector-stores-astra-db",
-        version: ">=0.4.0,<0.5.0",
-      });
-      break;
-    }
-    case "qdrant": {
-      dependencies.push({
-        name: "llama-index-vector-stores-qdrant",
-        version: ">=0.4.0,<0.5.0",
-        constraints: {
-          python: ">=3.11,<3.13",
-        },
-      });
-      break;
-    }
-    case "chroma": {
-      dependencies.push({
-        name: "llama-index-vector-stores-chroma",
-        version: ">=0.4.0,<0.5.0",
-      });
-      break;
-    }
-    case "weaviate": {
-      dependencies.push({
-        name: "llama-index-vector-stores-weaviate",
-        version: ">=1.2.3,<2.0.0",
-      });
-      break;
-    }
-    case "llamacloud":
-      dependencies.push({
-        name: "llama-index-indices-managed-llama-cloud",
-        version: ">=0.6.3,<0.7.0",
-      });
-      break;
-  }
-
-  // Add data source dependencies
-  if (dataSources) {
-    for (const ds of dataSources) {
-      const dsType = ds?.type;
-      switch (dsType) {
-        case "file":
-          dependencies.push({
-            name: "docx2txt",
-            version: ">=0.8,<0.9",
-          });
-          break;
-        case "web":
-          dependencies.push({
-            name: "llama-index-readers-web",
-            version: ">=0.3.0,<0.4.0",
-          });
-          break;
-        case "db":
-          dependencies.push({
-            name: "llama-index-readers-database",
-            version: ">=0.3.0,<0.4.0",
-          });
-          dependencies.push({
-            name: "pymysql",
-            version: ">=1.1.0,<2.0.0",
-            extras: ["rsa"],
-          });
-          dependencies.push({
-            name: "psycopg2-binary",
-            version: ">=2.9.9,<3.0.0",
-          });
-          break;
-      }
-    }
-  }
-
-  // Add tools dependencies
-  console.log("Adding tools dependencies");
-  tools?.forEach((tool) => {
-    tool.dependencies?.forEach((dep) => {
-      dependencies.push(dep);
-    });
-  });
-
-  switch (modelConfig.provider) {
-    case "ollama":
-      dependencies.push({
-        name: "llama-index-llms-ollama",
-        version: ">=0.5.0,<0.6.0",
-      });
-      dependencies.push({
-        name: "llama-index-embeddings-ollama",
-        version: ">=0.6.0,<0.7.0",
-      });
-      break;
-    case "openai":
-      if (templateType !== "multiagent") {
-        dependencies.push({
-          name: "llama-index-llms-openai",
-          version: ">=0.3.2,<0.4.0",
-        });
-        dependencies.push({
-          name: "llama-index-embeddings-openai",
-          version: ">=0.3.1,<0.4.0",
-        });
-        dependencies.push({
-          name: "llama-index-agent-openai",
-          version: ">=0.4.0,<0.5.0",
-        });
-      }
-      break;
-    case "groq":
-      dependencies.push({
-        name: "llama-index-llms-groq",
-        version: ">=0.3.0,<0.4.0",
-      });
-      dependencies.push({
-        name: "llama-index-embeddings-fastembed",
-        version: ">=0.3.0,<0.4.0",
-      });
-      break;
-    case "anthropic":
-      dependencies.push({
-        name: "llama-index-llms-anthropic",
-        version: ">=0.6.0,<0.7.0",
-      });
-      dependencies.push({
-        name: "llama-index-embeddings-fastembed",
-        version: ">=0.3.0,<0.4.0",
-      });
-      break;
-    case "gemini":
-      dependencies.push({
-        name: "llama-index-llms-gemini",
-        version: ">=0.4.0,<0.5.0",
-      });
-      dependencies.push({
-        name: "llama-index-embeddings-gemini",
-        version: ">=0.3.0,<0.4.0",
-      });
-      break;
-    case "mistral":
-      dependencies.push({
-        name: "llama-index-llms-mistralai",
-        version: ">=0.4.0,<0.5.0",
-      });
-      dependencies.push({
-        name: "llama-index-embeddings-mistralai",
-        version: ">=0.3.0,<0.4.0",
-      });
-      break;
-    case "azure-openai":
-      dependencies.push({
-        name: "llama-index-llms-azure-openai",
-        version: ">=0.3.0,<0.4.0",
-      });
-      dependencies.push({
-        name: "llama-index-embeddings-azure-openai",
-        version: ">=0.3.0,<0.4.0",
-      });
-      break;
-    case "huggingface":
-      dependencies.push({
-        name: "llama-index-llms-huggingface",
-        version: ">=0.5.0,<0.6.0",
-      });
-      dependencies.push({
-        name: "llama-index-embeddings-huggingface",
-        version: ">=0.5.0,<0.6.0",
-      });
-      dependencies.push({
-        name: "optimum",
-        version: ">=1.23.3,<2.0.0",
-        extras: ["onnxruntime"],
-      });
-      break;
-    case "t-systems":
-      dependencies.push({
-        name: "llama-index-agent-openai",
-        version: ">=0.4.0,<0.5.0",
-      });
-      dependencies.push({
-        name: "llama-index-llms-openai-like",
-        version: ">=0.3.0,<0.4.0",
-      });
-      break;
-  }
-
-  if (observability && observability !== "none") {
-    if (observability === "traceloop") {
-      dependencies.push({
-        name: "traceloop-sdk",
-        version: ">=0.15.11,<0.16.0",
-      });
-    }
-    if (observability === "llamatrace") {
-      dependencies.push({
-        name: "llama-index-callbacks-arize-phoenix",
-        version: ">=0.3.0,<0.4.0",
-      });
-    }
-  }
-
-  return dependencies;
-};
-
-const copyRouterCode = async (root: string, tools: Tool[]) => {
-  // Copy sandbox router if the artifact tool is selected
-  if (tools?.some((t) => t.name === "artifact")) {
-    await copy("sandbox.py", path.join(root, "app", "api", "routers"), {
-      parents: true,
-      cwd: path.join(templatesDir, "components", "routers", "python"),
-      rename: assetRelocator,
-    });
-  }
-};
-
-export const addDependencies = async (
-  projectDir: string,
-  dependencies: Dependency[],
-) => {
-  if (dependencies.length === 0) return;
-
-  const FILENAME = "pyproject.toml";
-  try {
-    // Parse toml file
-    const file = path.join(projectDir, FILENAME);
-    const fileContent = await fs.readFile(file, "utf8");
-    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.`,
-      );
-    }
-
-    // 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;
-        }
-      }
-    }
-
-    // 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
-    }
-  } catch (error) {
-    console.log(
-      `Error while updating dependencies for Poetry project file ${FILENAME}\n`,
-      error,
-    );
-  }
-};
-
-export const installPythonDependencies = () => {
-  if (isUvAvailable()) {
-    console.log(
-      `Installing Python dependencies using uv. This may take a while...`,
-    );
-    const installSuccessful = tryUvSync();
-    if (!installSuccessful) {
-      console.error(
-        red(
-          "Installing dependencies using uv failed. Please check the error log above and ensure uv is installed correctly.",
-        ),
-      );
-      process.exit(1);
-    }
-  } 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.`,
-      ),
-    );
-    process.exit(1);
-  }
-};
-
-const installLegacyPythonTemplate = async ({
-  root,
-  template,
-  vectorDb,
-  dataSources,
-  tools,
-  useCase,
-  observability,
-}: Pick<
-  InstallTemplateArgs,
-  | "root"
-  | "template"
-  | "vectorDb"
-  | "dataSources"
-  | "tools"
-  | "useCase"
-  | "observability"
->) => {
-  const compPath = path.join(templatesDir, "components");
-  const enginePath = path.join(root, "app", "engine");
-
-  // Copy selected vector DB
-  await copy("**", enginePath, {
-    parents: true,
-    cwd: path.join(compPath, "vectordbs", "python", vectorDb ?? "none"),
-  });
-
-  if (vectorDb !== "llamacloud") {
-    // Copy all loaders to enginePath
-    // Not needed for LlamaCloud as it has its own loaders
-    const loaderPath = path.join(enginePath, "loaders");
-    await copy("**", loaderPath, {
-      parents: true,
-      cwd: path.join(compPath, "loaders", "python"),
-    });
-  }
-
-  // Copy settings.py to app
-  await copy("**", path.join(root, "app"), {
-    cwd: path.join(compPath, "settings", "python"),
-  });
-
-  // Copy services
-  if (template == "streaming" || template == "multiagent") {
-    await copy("**", path.join(root, "app", "api", "services"), {
-      cwd: path.join(compPath, "services", "python"),
-    });
-  }
-  // Copy engine code
-  if (template === "streaming" || template === "multiagent") {
-    // Select and copy engine code based on data sources and tools
-    let engine;
-    // Multiagent always uses agent engine
-    if (template === "multiagent") {
-      engine = "agent";
-    } else {
-      // For streaming, use chat engine by default
-      // Unless tools are selected, in which case use agent engine
-      if (dataSources.length > 0 && (!tools || tools.length === 0)) {
-        console.log(
-          "\nNo tools selected - use optimized context chat engine\n",
-        );
-        engine = "chat";
-      } else {
-        engine = "agent";
-      }
-    }
-
-    // Copy engine code
-    await copy("**", enginePath, {
-      parents: true,
-      cwd: path.join(compPath, "engines", "python", engine),
-    });
-
-    // Copy router code
-    await copyRouterCode(root, tools ?? []);
-  }
-
-  // Copy multiagents overrides
-  if (template === "multiagent") {
-    await copy("**", path.join(root), {
-      cwd: path.join(compPath, "multiagent", "python"),
-    });
-  }
-
-  if (template === "multiagent" || template === "reflex") {
-    if (useCase) {
-      const sourcePath =
-        template === "multiagent"
-          ? path.join(compPath, "agents", "python", useCase)
-          : path.join(compPath, "reflex", useCase);
-
-      await copy("**", path.join(root), {
-        parents: true,
-        cwd: sourcePath,
-        rename: assetRelocator,
-      });
-    } else {
-      console.log(
-        red(
-          `There is no use case selected for ${template} template. Please pick a use case to use via --use-case flag.`,
-        ),
-      );
-      process.exit(1);
-    }
-  }
-
-  if (observability && observability !== "none") {
-    const templateObservabilityPath = path.join(
-      templatesDir,
-      "components",
-      "observability",
-      "python",
-      observability,
-    );
-    await copy("**", path.join(root, "app"), {
-      cwd: templateObservabilityPath,
-    });
-  }
-};
-
-const installLlamaIndexServerTemplate = async ({
-  root,
-  useCase,
-  useLlamaParse,
-}: Pick<InstallTemplateArgs, "root" | "useCase" | "useLlamaParse">) => {
-  if (!useCase) {
-    console.log(
-      red(
-        `There is no use case selected. Please pick a use case to use via --use-case flag.`,
-      ),
-    );
-    process.exit(1);
-  }
-
-  await copy("workflow.py", path.join(root, "app"), {
-    parents: true,
-    cwd: path.join(templatesDir, "components", "workflows", "python", useCase),
-  });
-
-  // Copy custom UI component code
-  await copy(`*`, path.join(root, "components"), {
-    parents: true,
-    cwd: path.join(templatesDir, "components", "ui", "workflows", useCase),
-  });
-
-  if (useLlamaParse) {
-    await copy("index.py", path.join(root, "app"), {
-      parents: true,
-      cwd: path.join(
-        templatesDir,
-        "components",
-        "vectordbs",
-        "llamaindexserver",
-        "llamacloud",
-        "python",
-      ),
-    });
-    // TODO: Consider moving generate.py to app folder.
-    await copy("generate.py", path.join(root), {
-      parents: true,
-      cwd: path.join(
-        templatesDir,
-        "components",
-        "vectordbs",
-        "llamaindexserver",
-        "llamacloud",
-        "python",
-      ),
-    });
-  }
-  // Copy README.md
-  await copy("README-template.md", path.join(root), {
-    parents: true,
-    cwd: path.join(templatesDir, "components", "workflows", "python", useCase),
-    rename: assetRelocator,
-  });
-};
-
-export const installPythonTemplate = async ({
-  appName,
-  root,
-  template,
-  framework,
-  vectorDb,
-  postInstallAction,
-  modelConfig,
-  dataSources,
-  tools,
-  useLlamaParse,
-  useCase,
-  observability,
-}: Pick<
-  InstallTemplateArgs,
-  | "appName"
-  | "root"
-  | "template"
-  | "framework"
-  | "vectorDb"
-  | "postInstallAction"
-  | "modelConfig"
-  | "dataSources"
-  | "tools"
-  | "useLlamaParse"
-  | "useCase"
-  | "observability"
->) => {
-  console.log("\nInitializing Python project with template:", template, "\n");
-  let templatePath;
-  if (template === "reflex") {
-    templatePath = path.join(templatesDir, "types", "reflex");
-  } else {
-    templatePath = path.join(templatesDir, "types", template, framework);
-  }
-  await copy("**", root, {
-    parents: true,
-    cwd: templatePath,
-    rename: assetRelocator,
-  });
-
-  if (template === "llamaindexserver") {
-    await installLlamaIndexServerTemplate({
-      root,
-      useCase,
-      useLlamaParse,
-    });
-  } else {
-    await installLegacyPythonTemplate({
-      root,
-      template,
-      vectorDb,
-      dataSources,
-      tools,
-      useCase,
-      observability,
-    });
-  }
-
-  console.log("Adding additional dependencies");
-  const addOnDependencies = getAdditionalDependencies(
-    modelConfig,
-    vectorDb,
-    dataSources,
-    tools,
-    template,
-  );
-
-  await addDependencies(root, addOnDependencies);
-
-  if (postInstallAction === "runApp" || postInstallAction === "dependencies") {
-    installPythonDependencies();
-  }
-};

packages/create-llama/helpers/run-app.ts

@@ -1,91 +0,0 @@
-import { SpawnOptions, spawn } from "child_process";
-import { TemplateFramework, TemplateType } from "./types";
-
-const createProcess = (
-  command: string,
-  args: string[],
-  options: SpawnOptions,
-): Promise<void> => {
-  return new Promise((resolve, reject) => {
-    spawn(command, args, {
-      ...options,
-      shell: true,
-    })
-      .on("exit", function (code) {
-        if (code !== 0) {
-          console.log(`Child process exited with code=${code}`);
-          reject(code);
-        } else {
-          resolve();
-        }
-      })
-      .on("error", function (err) {
-        console.log("Error when running child process: ", err);
-        reject(err);
-      });
-  });
-};
-
-export function runReflexApp(appPath: string, port: number) {
-  const commandArgs = [
-    "run",
-    "reflex",
-    "run",
-    "--frontend-port",
-    port.toString(),
-  ];
-  return createProcess("uv", 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, {
-    stdio: "inherit",
-    cwd: appPath,
-    env: { ...process.env, APP_PORT: `${port}` },
-  });
-}
-
-export function runTSApp(appPath: string, port: number) {
-  return createProcess("npm", ["run", "dev"], {
-    stdio: "inherit",
-    cwd: appPath,
-    env: { ...process.env, PORT: `${port}` },
-  });
-}
-
-export async function runApp(
-  appPath: string,
-  template: TemplateType,
-  framework: TemplateFramework,
-  port?: number,
-): Promise<void> {
-  try {
-    // Start the app
-    const defaultPort =
-      framework === "nextjs" || template === "reflex" ? 3000 : 8000;
-
-    const appRunner =
-      template === "reflex"
-        ? runReflexApp
-        : framework === "fastapi"
-          ? runFastAPIApp
-          : runTSApp;
-    await appRunner(appPath, port || defaultPort, template);
-  } catch (error) {
-    console.error("Failed to run app:", error);
-    throw error;
-  }
-}

packages/create-llama/helpers/tools.ts

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

packages/create-llama/helpers/types.ts

@@ -1,113 +0,0 @@
-import { PackageManager } from "../helpers/get-pkg-manager";
-import { Tool } from "./tools";
-
-export type ModelProvider =
-  | "openai"
-  | "groq"
-  | "ollama"
-  | "anthropic"
-  | "gemini"
-  | "mistral"
-  | "azure-openai"
-  | "huggingface"
-  | "t-systems";
-export type ModelConfig = {
-  provider: ModelProvider;
-  apiKey?: string;
-  model: string;
-  embeddingModel: string;
-  dimensions: number;
-  isConfigured(): boolean;
-};
-export type TemplateType =
-  | "streaming"
-  | "community"
-  | "llamapack"
-  | "multiagent"
-  | "reflex"
-  | "llamaindexserver";
-export type TemplateFramework = "nextjs" | "express" | "fastapi";
-export type TemplateUI = "html" | "shadcn";
-export type TemplateVectorDB =
-  | "none"
-  | "mongo"
-  | "pg"
-  | "pinecone"
-  | "milvus"
-  | "astra"
-  | "qdrant"
-  | "chroma"
-  | "llamacloud"
-  | "weaviate";
-export type TemplatePostInstallAction =
-  | "none"
-  | "VSCode"
-  | "dependencies"
-  | "runApp";
-export type TemplateDataSource = {
-  type: TemplateDataSourceType;
-  config: TemplateDataSourceConfig;
-};
-export type TemplateDataSourceType = "file" | "web" | "db";
-export type TemplateObservability = "none" | "traceloop" | "llamatrace";
-export type TemplateUseCase =
-  | "financial_report"
-  | "blog"
-  | "deep_research"
-  | "form_filling"
-  | "extractor"
-  | "contract_review"
-  | "agentic_rag";
-// Config for both file and folder
-export type FileSourceConfig =
-  | {
-      path: string;
-      filename?: string;
-    }
-  | {
-      url: URL;
-      filename?: string;
-    };
-export type WebSourceConfig = {
-  baseUrl?: string;
-  prefix?: string;
-  depth?: number;
-};
-export type DbSourceConfig = {
-  uri?: string;
-  queries?: string;
-};
-
-export type TemplateDataSourceConfig =
-  | FileSourceConfig
-  | WebSourceConfig
-  | DbSourceConfig;
-
-export type CommunityProjectConfig = {
-  owner: string;
-  repo: string;
-  branch: string;
-  filePath?: string;
-};
-
-export interface InstallTemplateArgs {
-  appName: string;
-  root: string;
-  packageManager: PackageManager;
-  isOnline: boolean;
-  template: TemplateType;
-  framework: TemplateFramework;
-  ui: TemplateUI;
-  dataSources: TemplateDataSource[];
-  modelConfig: ModelConfig;
-  llamaCloudKey?: string;
-  useLlamaParse?: boolean;
-  communityProjectConfig?: CommunityProjectConfig;
-  llamapack?: string;
-  vectorDb?: TemplateVectorDB;
-  port?: number;
-  postInstallAction?: TemplatePostInstallAction;
-  tools?: Tool[];
-  observability?: TemplateObservability;
-  useCase?: TemplateUseCase;
-}

packages/create-llama/helpers/typescript.ts

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

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/helpers/vscode.ts

@@ -1,70 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { assetRelocator, copy } from "./copy";
-import { TemplateFramework } from "./types";
-
-function renderDevcontainerContent(
-  templatesDir: string,
-  framework: TemplateFramework,
-) {
-  const devcontainerJson: any = JSON.parse(
-    fs.readFileSync(path.join(templatesDir, "devcontainer.json"), "utf8"),
-  );
-
-  // Modify postCreateCommand
-  devcontainerJson.postCreateCommand =
-    framework === "fastapi" ? "poetry install" : "npm install";
-
-  // Modify containerEnv
-  if (framework === "fastapi") {
-    devcontainerJson.containerEnv = {
-      ...devcontainerJson.containerEnv,
-      PYTHONPATH: "${PYTHONPATH}:${workspaceFolder}",
-    };
-  }
-
-  return JSON.stringify(devcontainerJson, null, 2);
-}
-
-export const writeDevcontainer = async (
-  root: string,
-  templatesDir: string,
-  framework: TemplateFramework,
-) => {
-  const devcontainerDir = path.join(root, ".devcontainer");
-  if (fs.existsSync(devcontainerDir)) {
-    console.log("Template already has a .devcontainer. Using it.");
-    return;
-  }
-  const devcontainerContent = renderDevcontainerContent(
-    templatesDir,
-    framework,
-  );
-  fs.mkdirSync(devcontainerDir);
-  await fs.promises.writeFile(
-    path.join(devcontainerDir, "devcontainer.json"),
-    devcontainerContent,
-  );
-};
-
-export const copyVSCodeSettings = async (
-  root: string,
-  templatesDir: string,
-) => {
-  const vscodeDir = path.join(root, ".vscode");
-  await copy("vscode_settings.json", vscodeDir, {
-    cwd: templatesDir,
-    rename: assetRelocator,
-  });
-};
-
-export const configVSCode = async (
-  root: string,
-  templatesDir: string,
-  framework: TemplateFramework,
-) => {
-  await writeDevcontainer(root, templatesDir, framework);
-  if (framework === "fastapi") {
-    await copyVSCodeSettings(root, templatesDir);
-  }
-};

packages/create-llama/package.json

@@ -1,83 +0,0 @@
-{
-  "name": "create-llama",
-  "version": "0.5.11",
-  "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",
-    "format": "prettier --ignore-unknown --cache --check .",
-    "format:write": "prettier --ignore-unknown --write .",
-    "lint": "eslint . --ignore-pattern dist --ignore-pattern e2e/cache",
-    "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": {
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^8.10.0",
-    "prettier": "^3.2.5",
-    "prettier-plugin-organize-imports": "^3.2.4",
-    "@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/ci.ts

@@ -1,30 +0,0 @@
-import { askModelConfig } from "../helpers/providers";
-import { QuestionArgs, QuestionResults } from "./types";
-
-const defaults: Omit<QuestionArgs, "modelConfig"> = {
-  template: "streaming",
-  framework: "nextjs",
-  ui: "shadcn",
-  frontend: false,
-  llamaCloudKey: "",
-  useLlamaParse: false,
-  communityProjectConfig: undefined,
-  llamapack: "",
-  postInstallAction: "dependencies",
-  dataSources: [],
-  tools: [],
-};
-
-export async function getCIQuestionResults(
-  program: QuestionArgs,
-): Promise<QuestionResults> {
-  return {
-    ...defaults,
-    ...program,
-    modelConfig: await askModelConfig({
-      openAiKey: program.openAiKey,
-      askModels: false,
-      framework: program.framework,
-    }),
-  };
-}

packages/create-llama/questions/datasources.ts

@@ -1,64 +0,0 @@
-import {
-  TemplateDataSource,
-  TemplateFramework,
-  TemplateType,
-} from "../helpers";
-import { supportedContextFileTypes } from "./utils";
-
-export const getDataSourceChoices = (
-  framework: TemplateFramework,
-  selectedDataSource: TemplateDataSource[],
-  template?: TemplateType,
-) => {
-  const choices = [];
-
-  if (selectedDataSource.length > 0) {
-    choices.push({
-      title: "No",
-      value: "no",
-    });
-  }
-  if (selectedDataSource === undefined || selectedDataSource.length === 0) {
-    choices.push({
-      title: "No datasource",
-      value: "none",
-    });
-    choices.push({
-      title:
-        process.platform !== "linux"
-          ? "Use an example PDF"
-          : "Use an example PDF (you can add your own data files later)",
-      value: "exampleFile",
-    });
-  }
-
-  // Linux has many distros so we won't support file/folder picker for now
-  if (process.platform !== "linux") {
-    choices.push(
-      {
-        title: `Use local files (${supportedContextFileTypes.join(", ")})`,
-        value: "file",
-      },
-      {
-        title:
-          process.platform === "win32"
-            ? "Use a local folder"
-            : "Use local folders",
-        value: "folder",
-      },
-    );
-  }
-
-  if (framework === "fastapi" && template !== "reflex") {
-    choices.push({
-      title: "Use website content (requires Chrome)",
-      value: "web",
-    });
-    choices.push({
-      title: "Use data from a database (Mysql, PostgreSQL)",
-      value: "db",
-    });
-  }
-
-  return choices;
-};

packages/create-llama/questions/index.ts

@@ -1,21 +0,0 @@
-import ciInfo from "ci-info";
-import { getCIQuestionResults } from "./ci";
-import { askProQuestions } from "./questions";
-import { askSimpleQuestions } from "./simple";
-import { QuestionArgs, QuestionResults } from "./types";
-
-export const isCI = ciInfo.isCI || process.env.PLAYWRIGHT_TEST === "1";
-
-export const askQuestions = async (
-  args: QuestionArgs,
-): Promise<QuestionResults> => {
-  if (isCI) {
-    return await getCIQuestionResults(args);
-  } else if (args.pro) {
-    // TODO: refactor pro questions to return a result object
-    await askProQuestions(args);
-    return args as unknown as QuestionResults;
-  }
-  const results = await askSimpleQuestions(args);
-  return results;
-};

packages/create-llama/questions/questions.ts

@@ -1,459 +0,0 @@
-import { blue } from "picocolors";
-import prompts from "prompts";
-import { isCI } from ".";
-import { COMMUNITY_OWNER, COMMUNITY_REPO } from "../helpers/constant";
-import { EXAMPLE_FILE, EXAMPLE_GDPR } from "../helpers/datasources";
-import { getAvailableLlamapackOptions } from "../helpers/llama-pack";
-import { askModelConfig } from "../helpers/providers";
-import { getProjectOptions } from "../helpers/repo";
-import { supportedTools, toolRequiresConfig } from "../helpers/tools";
-import { getDataSourceChoices } from "./datasources";
-import { getVectorDbChoices } from "./stores";
-import { QuestionArgs } from "./types";
-import {
-  askPostInstallAction,
-  onPromptState,
-  questionHandlers,
-  selectLocalContextData,
-} from "./utils";
-
-export const askProQuestions = async (program: QuestionArgs) => {
-  if (!program.template) {
-    const styledRepo = blue(
-      `https://github.com/${COMMUNITY_OWNER}/${COMMUNITY_REPO}`,
-    );
-    const { template } = await prompts(
-      {
-        type: "select",
-        name: "template",
-        message: "Which template would you like to use?",
-        choices: [
-          { title: "Agentic RAG (e.g. chat with docs)", value: "streaming" },
-          {
-            title: "Multi-agent app (using workflows)",
-            value: "multiagent",
-          },
-          { title: "Fullstack python template with Reflex", value: "reflex" },
-          {
-            title: `Community template from ${styledRepo}`,
-            value: "community",
-          },
-          {
-            title: "Example using a LlamaPack",
-            value: "llamapack",
-          },
-        ],
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    program.template = template;
-  }
-
-  if (program.template === "community") {
-    const projectOptions = await getProjectOptions(
-      COMMUNITY_OWNER,
-      COMMUNITY_REPO,
-    );
-    const { communityProjectConfig } = await prompts(
-      {
-        type: "select",
-        name: "communityProjectConfig",
-        message: "Select community template",
-        choices: projectOptions.map(({ title, value }) => ({
-          title,
-          value: JSON.stringify(value), // serialize value to string in terminal
-        })),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    const projectConfig = JSON.parse(communityProjectConfig);
-    program.communityProjectConfig = projectConfig;
-    return; // early return - no further questions needed for community projects
-  }
-
-  if (program.template === "llamapack") {
-    const availableLlamaPacks = await getAvailableLlamapackOptions();
-    const { llamapack } = await prompts(
-      {
-        type: "select",
-        name: "llamapack",
-        message: "Select LlamaPack",
-        choices: availableLlamaPacks.map((pack) => ({
-          title: pack.name,
-          value: pack.folderPath,
-        })),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    program.llamapack = llamapack;
-    if (!program.postInstallAction) {
-      program.postInstallAction = await askPostInstallAction(program);
-    }
-    return; // early return - no further questions needed for llamapack projects
-  }
-
-  if (program.template === "reflex") {
-    // Reflex template only supports FastAPI, empty data sources, and llamacloud
-    // So we just use example file for extractor template, this allows user to choose vector database later
-    program.dataSources = [EXAMPLE_FILE];
-    program.framework = "fastapi";
-    // Ask for which Reflex use case to use
-    const { useCase } = await prompts(
-      {
-        type: "select",
-        name: "useCase",
-        message: "Which use case would you like to build?",
-        choices: [
-          { title: "Structured Extractor", value: "extractor" },
-          {
-            title: "Contract review (using Workflow)",
-            value: "contract_review",
-          },
-        ],
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    program.useCase = useCase;
-  }
-
-  if (!program.framework) {
-    const choices = [
-      { title: "NextJS", value: "nextjs" },
-      { title: "Express", value: "express" },
-      { title: "FastAPI (Python)", value: "fastapi" },
-    ];
-
-    const { framework } = await prompts(
-      {
-        type: "select",
-        name: "framework",
-        message: "Which framework would you like to use?",
-        choices,
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    program.framework = framework;
-  }
-
-  if (
-    program.framework === "fastapi" &&
-    (program.template === "streaming" || program.template === "multiagent")
-  ) {
-    // if a backend-only framework is selected, ask whether we should create a frontend
-    if (program.frontend === undefined) {
-      const styledNextJS = blue("NextJS");
-      const { frontend } = await prompts({
-        onState: onPromptState,
-        type: "toggle",
-        name: "frontend",
-        message: `Would you like to generate a ${styledNextJS} frontend for your FastAPI backend?`,
-        initial: false,
-        active: "Yes",
-        inactive: "No",
-      });
-      program.frontend = Boolean(frontend);
-    }
-  } else {
-    program.frontend = false;
-  }
-
-  if (program.framework === "nextjs" || program.frontend) {
-    if (!program.ui) {
-      program.ui = "shadcn";
-    }
-  }
-
-  if (!program.observability && program.template === "streaming") {
-    const { observability } = await prompts(
-      {
-        type: "select",
-        name: "observability",
-        message: "Would you like to set up observability?",
-        choices: [
-          { title: "No", value: "none" },
-          ...(program.framework === "fastapi"
-            ? [{ title: "LlamaTrace", value: "llamatrace" }]
-            : []),
-          { title: "Traceloop", value: "traceloop" },
-        ],
-        initial: 0,
-      },
-      questionHandlers,
-    );
-
-    program.observability = observability;
-  }
-
-  if (
-    (program.template === "reflex" || program.template === "multiagent") &&
-    !program.useCase
-  ) {
-    const choices =
-      program.template === "reflex"
-        ? [
-            { title: "Structured Extractor", value: "extractor" },
-            {
-              title: "Contract review (using Workflow)",
-              value: "contract_review",
-            },
-          ]
-        : [
-            {
-              title: "Financial report (generate a financial report)",
-              value: "financial_report",
-            },
-            {
-              title: "Form filling (fill missing value in a CSV file)",
-              value: "form_filling",
-            },
-            { title: "Blog writer (Write a blog post)", value: "blog" },
-          ];
-
-    const { useCase } = await prompts(
-      {
-        type: "select",
-        name: "useCase",
-        message: "Which use case would you like to use?",
-        choices,
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    program.useCase = useCase;
-  }
-
-  // Configure framework and data sources for Reflex template
-  if (program.template === "reflex") {
-    program.framework = "fastapi";
-
-    program.dataSources =
-      program.useCase === "extractor" ? [EXAMPLE_FILE] : [EXAMPLE_GDPR];
-  }
-
-  if (!program.modelConfig) {
-    const modelConfig = await askModelConfig({
-      openAiKey: program.openAiKey,
-      askModels: program.askModels ?? false,
-      framework: program.framework,
-    });
-    program.modelConfig = modelConfig;
-  }
-
-  if (!program.vectorDb) {
-    const { vectorDb } = await prompts(
-      {
-        type: "select",
-        name: "vectorDb",
-        message: "Would you like to use a vector database?",
-        choices: getVectorDbChoices(program.framework),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    program.vectorDb = vectorDb;
-  }
-
-  if (program.vectorDb === "llamacloud" && program.dataSources.length === 0) {
-    // When using a LlamaCloud index and no data sources are provided, just copy an example file
-    program.dataSources = [EXAMPLE_FILE];
-  }
-
-  if (!program.dataSources) {
-    program.dataSources = [];
-    // continue asking user for data sources if none are initially provided
-    while (true) {
-      const firstQuestion = program.dataSources.length === 0;
-      const choices = getDataSourceChoices(
-        program.framework,
-        program.dataSources,
-        program.template,
-      );
-      if (choices.length === 0) break;
-      const { selectedSource } = await prompts(
-        {
-          type: "select",
-          name: "selectedSource",
-          message: firstQuestion
-            ? "Which data source would you like to use?"
-            : "Would you like to add another data source?",
-          choices,
-          initial: firstQuestion ? 1 : 0,
-        },
-        questionHandlers,
-      );
-
-      if (selectedSource === "no" || selectedSource === "none") {
-        // user doesn't want another data source or any data source
-        break;
-      }
-      switch (selectedSource) {
-        case "exampleFile": {
-          program.dataSources.push(EXAMPLE_FILE);
-          break;
-        }
-        case "file":
-        case "folder": {
-          const selectedPaths = await selectLocalContextData(selectedSource);
-          for (const p of selectedPaths) {
-            program.dataSources.push({
-              type: "file",
-              config: {
-                path: p,
-              },
-            });
-          }
-          break;
-        }
-        case "web": {
-          const { baseUrl } = await prompts(
-            {
-              type: "text",
-              name: "baseUrl",
-              message: "Please provide base URL of the website: ",
-              initial: "https://www.llamaindex.ai",
-              validate: (value: string) => {
-                if (!value.includes("://")) {
-                  value = `https://${value}`;
-                }
-                const urlObj = new URL(value);
-                if (
-                  urlObj.protocol !== "https:" &&
-                  urlObj.protocol !== "http:"
-                ) {
-                  return `URL=${value} has invalid protocol, only allow http or https`;
-                }
-                return true;
-              },
-            },
-            questionHandlers,
-          );
-
-          program.dataSources.push({
-            type: "web",
-            config: {
-              baseUrl,
-              prefix: baseUrl,
-              depth: 1,
-            },
-          });
-          break;
-        }
-        case "db": {
-          const dbPrompts: prompts.PromptObject<string>[] = [
-            {
-              type: "text",
-              name: "uri",
-              message:
-                "Please enter the connection string (URI) for the database.",
-              initial: "mysql+pymysql://user:pass@localhost:3306/mydb",
-              validate: (value: string) => {
-                if (!value) {
-                  return "Please provide a valid connection string";
-                } else if (
-                  !(
-                    value.startsWith("mysql+pymysql://") ||
-                    value.startsWith("postgresql+psycopg://")
-                  )
-                ) {
-                  return "The connection string must start with 'mysql+pymysql://' for MySQL or 'postgresql+psycopg://' for PostgreSQL";
-                }
-                return true;
-              },
-            },
-            // Only ask for a query, user can provide more complex queries in the config file later
-            {
-              type: (prev) => (prev ? "text" : null),
-              name: "queries",
-              message: "Please enter the SQL query to fetch data:",
-              initial: "SELECT * FROM mytable",
-            },
-          ];
-          program.dataSources.push({
-            type: "db",
-            config: await prompts(dbPrompts, questionHandlers),
-          });
-          break;
-        }
-      }
-    }
-  }
-
-  const isUsingLlamaCloud = program.vectorDb === "llamacloud";
-
-  // Asking for LlamaParse if user selected file data source
-  if (isUsingLlamaCloud) {
-    // default to use LlamaParse if using LlamaCloud
-    program.useLlamaParse = true;
-  } else {
-    // Reflex template doesn't support LlamaParse right now (cannot use asyncio loop in Reflex)
-    if (program.useLlamaParse === undefined && program.template !== "reflex") {
-      // if already set useLlamaParse, don't ask again
-      if (program.dataSources.some((ds) => ds.type === "file")) {
-        const { useLlamaParse } = await prompts(
-          {
-            type: "toggle",
-            name: "useLlamaParse",
-            message:
-              "Would you like to use LlamaParse (improved parser for RAG - requires API key)?",
-            initial: false,
-            active: "Yes",
-            inactive: "No",
-          },
-          questionHandlers,
-        );
-        program.useLlamaParse = useLlamaParse;
-      }
-    }
-  }
-
-  // Ask for LlamaCloud API key when using a LlamaCloud index or LlamaParse
-  if (isUsingLlamaCloud || program.useLlamaParse) {
-    if (!program.llamaCloudKey && !isCI) {
-      // if already set, don't ask again
-      // Ask for LlamaCloud API key
-      const { llamaCloudKey } = await prompts(
-        {
-          type: "text",
-          name: "llamaCloudKey",
-          message:
-            "Please provide your LlamaCloud API key (leave blank to skip):",
-        },
-        questionHandlers,
-      );
-      program.llamaCloudKey = llamaCloudKey || process.env.LLAMA_CLOUD_API_KEY;
-    }
-  }
-
-  if (
-    !program.tools &&
-    (program.template === "streaming" || program.template === "multiagent")
-  ) {
-    const options = supportedTools.filter((t) =>
-      t.supportedFrameworks?.includes(program.framework),
-    );
-    const toolChoices = options.map((tool) => ({
-      title: `${tool.display}${toolRequiresConfig(tool) ? " (needs configuration)" : ""}`,
-      value: tool.name,
-    }));
-    const { toolsName } = await prompts({
-      type: "multiselect",
-      name: "toolsName",
-      message:
-        "Would you like to build an agent using tools? If so, select the tools here, otherwise just press enter",
-      choices: toolChoices,
-    });
-    const tools = toolsName?.map((tool: string) =>
-      supportedTools.find((t) => t.name === tool),
-    );
-    program.tools = tools;
-  }
-
-  if (!program.postInstallAction) {
-    program.postInstallAction = await askPostInstallAction(program);
-  }
-};

packages/create-llama/questions/simple.ts

@@ -1,166 +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";
-
-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.",
-        },
-      ],
-    },
-    questionHandlers,
-  );
-
-  let language: TemplateFramework = "fastapi";
-  let llamaCloudKey = args.llamaCloudKey;
-
-  let useLlamaCloud = false;
-
-  if (appType !== "extractor" && appType !== "contract_review") {
-    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;
-  }
-
-  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_GPT4o: ModelConfig = {
-    provider: "openai",
-    apiKey: args.openAiKey,
-    model: "gpt-4o",
-    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_GPT4o,
-    },
-    deep_research: {
-      template: "llamaindexserver",
-      dataSources: EXAMPLE_10K_SEC_FILES,
-      tools: [],
-      modelConfig: MODEL_GPT4o,
-    },
-  };
-
-  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,
-  };
-};

packages/create-llama/questions/stores.ts

@@ -1,36 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { TemplateFramework } from "../helpers";
-import { templatesDir } from "../helpers/dir";
-
-export const getVectorDbChoices = (framework: TemplateFramework) => {
-  const choices = [
-    {
-      title: "No, just store the data in the file system",
-      value: "none",
-    },
-    { title: "MongoDB", value: "mongo" },
-    { title: "PostgreSQL", value: "pg" },
-    { title: "Pinecone", value: "pinecone" },
-    { title: "Milvus", value: "milvus" },
-    { title: "Astra", value: "astra" },
-    { title: "Qdrant", value: "qdrant" },
-    { title: "ChromaDB", value: "chroma" },
-    { title: "Weaviate", value: "weaviate" },
-    { title: "LlamaCloud (use Managed Index)", value: "llamacloud" },
-  ];
-
-  const vectordbLang = framework === "fastapi" ? "python" : "typescript";
-  const compPath = path.join(templatesDir, "components");
-  const vectordbPath = path.join(compPath, "vectordbs", vectordbLang);
-
-  const availableChoices = fs
-    .readdirSync(vectordbPath)
-    .filter((file) => fs.statSync(path.join(vectordbPath, file)).isDirectory());
-
-  const displayedChoices = choices.filter((choice) =>
-    availableChoices.includes(choice.value),
-  );
-
-  return displayedChoices;
-};

packages/create-llama/questions/types.ts

@@ -1,15 +0,0 @@
-import { InstallAppArgs } from "../create-app";
-
-export type QuestionResults = Omit<
-  InstallAppArgs,
-  "appPath" | "packageManager"
->;
-
-export type PureQuestionArgs = {
-  askModels?: boolean;
-  pro?: boolean;
-  openAiKey?: string;
-  llamaCloudKey?: string;
-};
-
-export type QuestionArgs = QuestionResults & PureQuestionArgs;

packages/create-llama/questions/utils.ts

@@ -1,178 +0,0 @@
-import { execSync } from "child_process";
-import fs from "fs";
-import path from "path";
-import { red } from "picocolors";
-import prompts from "prompts";
-import { TemplateDataSourceType, TemplatePostInstallAction } from "../helpers";
-import { toolsRequireConfig } from "../helpers/tools";
-import { QuestionResults } from "./types";
-
-export const supportedContextFileTypes = [
-  ".pdf",
-  ".doc",
-  ".docx",
-  ".xls",
-  ".xlsx",
-  ".csv",
-];
-
-const MACOS_FILE_SELECTION_SCRIPT = `
-osascript -l JavaScript -e '
-  a = Application.currentApplication();
-  a.includeStandardAdditions = true;
-  a.chooseFile({ withPrompt: "Please select files to process:", multipleSelectionsAllowed: true }).map(file => file.toString())
-'`;
-
-const MACOS_FOLDER_SELECTION_SCRIPT = `
-osascript -l JavaScript -e '
-  a = Application.currentApplication();
-  a.includeStandardAdditions = true;
-  a.chooseFolder({ withPrompt: "Please select folders to process:", multipleSelectionsAllowed: true }).map(folder => folder.toString())
-'`;
-
-const WINDOWS_FILE_SELECTION_SCRIPT = `
-Add-Type -AssemblyName System.Windows.Forms
-$openFileDialog = New-Object System.Windows.Forms.OpenFileDialog
-$openFileDialog.InitialDirectory = [Environment]::GetFolderPath('Desktop')
-$openFileDialog.Multiselect = $true
-$result = $openFileDialog.ShowDialog()
-if ($result -eq 'OK') {
-  $openFileDialog.FileNames
-}
-`;
-
-const WINDOWS_FOLDER_SELECTION_SCRIPT = `
-Add-Type -AssemblyName System.windows.forms
-$folderBrowser = New-Object System.Windows.Forms.FolderBrowserDialog
-$dialogResult = $folderBrowser.ShowDialog()
-if ($dialogResult -eq [System.Windows.Forms.DialogResult]::OK)
-{
-    $folderBrowser.SelectedPath
-}
-`;
-
-export const selectLocalContextData = async (type: TemplateDataSourceType) => {
-  try {
-    let selectedPath: string = "";
-    let execScript: string;
-    let execOpts: any = {};
-    switch (process.platform) {
-      case "win32": // Windows
-        execScript =
-          type === "file"
-            ? WINDOWS_FILE_SELECTION_SCRIPT
-            : WINDOWS_FOLDER_SELECTION_SCRIPT;
-        execOpts = { shell: "powershell.exe" };
-        break;
-      case "darwin": // MacOS
-        execScript =
-          type === "file"
-            ? MACOS_FILE_SELECTION_SCRIPT
-            : MACOS_FOLDER_SELECTION_SCRIPT;
-        break;
-      default: // Unsupported OS
-        console.log(red("Unsupported OS error!"));
-        process.exit(1);
-    }
-    selectedPath = execSync(execScript, execOpts).toString().trim();
-    const paths =
-      process.platform === "win32"
-        ? selectedPath.split("\r\n")
-        : selectedPath.split(", ");
-
-    for (const p of paths) {
-      if (
-        fs.statSync(p).isFile() &&
-        !supportedContextFileTypes.includes(path.extname(p))
-      ) {
-        console.log(
-          red(
-            `Please select a supported file type: ${supportedContextFileTypes}`,
-          ),
-        );
-        process.exit(1);
-      }
-    }
-    return paths;
-  } catch (error) {
-    console.log(
-      red(
-        "Got an error when trying to select local context data! Please try again or select another data source option.",
-      ),
-    );
-    process.exit(1);
-  }
-};
-
-export const onPromptState = (state: any) => {
-  if (state.aborted) {
-    // If we don't re-enable the terminal cursor before exiting
-    // the program, the cursor will remain hidden
-    process.stdout.write("\x1B[?25h");
-    process.stdout.write("\n");
-    process.exit(1);
-  }
-};
-
-export const toChoice = (value: string) => {
-  return { title: value, value };
-};
-
-export const questionHandlers = {
-  onCancel: () => {
-    console.error("Exiting.");
-    process.exit(1);
-  },
-};
-
-// Ask for next action after installation
-export async function askPostInstallAction(
-  args: QuestionResults,
-): Promise<TemplatePostInstallAction> {
-  const actionChoices = [
-    {
-      title: "Just generate code (~1 sec)",
-      value: "none",
-    },
-    {
-      title: "Start in VSCode (~1 sec)",
-      value: "VSCode",
-    },
-    {
-      title: "Generate code and install dependencies (~2 min)",
-      value: "dependencies",
-    },
-  ];
-
-  const modelConfigured = !args.llamapack && args.modelConfig.isConfigured();
-  // If using LlamaParse, require LlamaCloud API key
-  const llamaCloudKeyConfigured = args.useLlamaParse
-    ? args.llamaCloudKey || process.env["LLAMA_CLOUD_API_KEY"]
-    : true;
-  const hasVectorDb = args.vectorDb && args.vectorDb !== "none";
-  // Can run the app if all tools do not require configuration
-  if (
-    !hasVectorDb &&
-    modelConfigured &&
-    llamaCloudKeyConfigured &&
-    !toolsRequireConfig(args.tools)
-  ) {
-    actionChoices.push({
-      title: "Generate code, install dependencies, and run the app (~2 min)",
-      value: "runApp",
-    });
-  }
-
-  const { action } = await prompts(
-    {
-      type: "select",
-      name: "action",
-      message: "How would you like to proceed?",
-      choices: actionChoices,
-      initial: 1,
-    },
-    questionHandlers,
-  );
-
-  return action;
-}

packages/create-llama/scripts/build.sh

@@ -1,12 +0,0 @@
-#!/usr/bin/env bash
-
-# build dist/index.js file
-pnpm run build:ncc
-
-# add shebang to the top of dist/index.js
-# XXX: Windows needs a space after `node` to work correctly
-# Note: ncc can handle shebang but it didn't work with Windows in our tests
-echo '#!/usr/bin/env node ' | cat - dist/index.js >temp && mv temp dist/index.js
-
-# make dist/index.js executable
-chmod +x dist/index.js

packages/create-llama/scripts/pack.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-
-pnpm pack && npm install -g $(pwd)/$(ls ./*.tgz | head -1)

packages/create-llama/templates/components/agents/python/blog/README-template.md

@@ -1,68 +0,0 @@
-## Overview
-
-This example is using three agents to generate a blog post:
-
-- a researcher that retrieves content via a RAG pipeline,
-- a writer that specializes in writing blog posts and
-- a reviewer that is reviewing the blog post.
-
-There are three different methods how the agents can interact to reach their goal:
-
-1. [Choreography](./app/agents/choreography.py) - the agents decide themselves to delegate a task to another agent
-1. [Orchestrator](./app/agents/orchestrator.py) - a central orchestrator decides which agent should execute a task
-1. [Explicit Workflow](./app/agents/workflow.py) - a pre-defined workflow specific for the task is used to execute the tasks
-
-## Getting Started
-
-First, setup the environment with poetry:
-
-> **_Note:_** This step is not needed if you are using the dev-container.
-
-```shell
-uv sync
-```
-
-Then check the parameters that have been pre-configured in the `.env` file in this directory. (E.g. you might need to configure an `OPENAI_API_KEY` if you're using OpenAI as model provider).
-Second, generate the embeddings of the documents in the `./data` directory:
-
-```shell
-uv run generate
-```
-
-Third, run the development server:
-
-```shell
-uv run dev
-```
-
-Per default, the example is using the explicit workflow. You can change the example by setting the `EXAMPLE_TYPE` environment variable to `choreography` or `orchestrator`.
-The example provides one streaming API endpoint `/api/chat`.
-You can test the endpoint with the following curl request:
-
-```
-curl --location 'localhost:8000/api/chat' \
---header 'Content-Type: application/json' \
---data '{ "messages": [{ "role": "user", "content": "Write a blog post about physical standards for letters" }] }'
-```
-
-You can start editing the API by modifying `app/api/routers/chat.py` or `app/examples/workflow.py`. The API auto-updates as you save the files.
-
-Open [http://localhost:8000](http://localhost:8000) with your browser to start the app.
-
-To start the app optimized for **production**, run:
-
-```
-uv run prod
-```
-
-## Deployments
-
-For production deployments, check the [DEPLOY.md](DEPLOY.md) file.
-
-## Learn More
-
-To learn more about LlamaIndex, take a look at the following resources:
-
-- [LlamaIndex Documentation](https://docs.llamaindex.ai) - learn about LlamaIndex.
-- [Workflows Introduction](https://docs.llamaindex.ai/en/stable/understanding/workflows/) - learn about LlamaIndex workflows.
-  You can check out [the LlamaIndex GitHub repository](https://github.com/run-llama/llama_index) - your feedback and contributions are welcome!

packages/create-llama/templates/components/agents/python/blog/app/agents/choreography.py

@@ -1,34 +0,0 @@
-from textwrap import dedent
-from typing import List, Optional
-
-from app.agents.publisher import create_publisher
-from app.agents.researcher import create_researcher
-from app.workflows.multi import AgentCallingAgent
-from app.workflows.single import FunctionCallingAgent
-from llama_index.core.chat_engine.types import ChatMessage
-
-
-def create_choreography(chat_history: Optional[List[ChatMessage]] = None, **kwargs):
-    researcher = create_researcher(chat_history, **kwargs)
-    publisher = create_publisher(chat_history)
-    reviewer = FunctionCallingAgent(
-        name="reviewer",
-        description="expert in reviewing blog posts, needs a written post to review",
-        system_prompt="You are an expert in reviewing blog posts. You are given a task to review a blog post. Review the post for logical inconsistencies, ask critical questions, and provide suggestions for improvement. Furthermore, proofread the post for grammar and spelling errors. If the post is good, you can say 'The post is good.'",
-        chat_history=chat_history,
-    )
-    return AgentCallingAgent(
-        name="writer",
-        agents=[researcher, reviewer, publisher],
-        description="expert in writing blog posts, needs researched information and images to write a blog post",
-        system_prompt=dedent(
-            """
-            You are an expert in writing blog posts. You are given a task to write a blog post. Before starting to write the post, consult the researcher agent to get the information you need. Don't make up any information yourself.
-            After creating a draft for the post, send it to the reviewer agent to receive feedback and make sure to incorporate the feedback from the reviewer.
-            You can consult the reviewer and researcher a maximum of two times. Your output should contain only the blog post.
-            Finally, always request the publisher to create a document (PDF, HTML) and publish the blog post.
-        """
-        ),
-        # TODO: add chat_history support to AgentCallingAgent
-        # chat_history=chat_history,
-    )

packages/create-llama/templates/components/agents/python/blog/app/agents/orchestrator.py

@@ -1,44 +0,0 @@
-from textwrap import dedent
-from typing import List, Optional
-
-from app.agents.publisher import create_publisher
-from app.agents.researcher import create_researcher
-from app.workflows.multi import AgentOrchestrator
-from app.workflows.single import FunctionCallingAgent
-from llama_index.core.chat_engine.types import ChatMessage
-
-
-def create_orchestrator(chat_history: Optional[List[ChatMessage]] = None, **kwargs):
-    researcher = create_researcher(chat_history, **kwargs)
-    writer = FunctionCallingAgent(
-        name="writer",
-        description="expert in writing blog posts, need information and images to write a post",
-        system_prompt=dedent(
-            """
-            You are an expert in writing blog posts.
-            You are given a task to write a blog post. Do not make up any information yourself.
-            If you don't have the necessary information to write a blog post, reply "I need information about the topic to write the blog post".
-            If you need to use images, reply "I need images about the topic to write the blog post". Do not use any dummy images made up by you.
-            If you have all the information needed, write the blog post.
-        """
-        ),
-        chat_history=chat_history,
-    )
-    reviewer = FunctionCallingAgent(
-        name="reviewer",
-        description="expert in reviewing blog posts, needs a written blog post to review",
-        system_prompt=dedent(
-            """
-            You are an expert in reviewing blog posts. You are given a task to review a blog post. Review the post and fix any issues found yourself. You must output a final blog post.
-            A post must include at least one valid image. If not, reply "I need images about the topic to write the blog post". An image URL starting with "example" or "your website" is not valid.
-            Especially check for logical inconsistencies and proofread the post for grammar and spelling errors.
-        """
-        ),
-        chat_history=chat_history,
-    )
-    publisher = create_publisher(chat_history)
-    return AgentOrchestrator(
-        agents=[writer, reviewer, researcher, publisher],
-        refine_plan=False,
-        chat_history=chat_history,
-    )

packages/create-llama/templates/components/agents/python/blog/app/agents/publisher.py

@@ -1,35 +0,0 @@
-from textwrap import dedent
-from typing import List, Tuple
-
-from app.engine.tools import ToolFactory
-from app.workflows.single import FunctionCallingAgent
-from llama_index.core.chat_engine.types import ChatMessage
-from llama_index.core.tools import FunctionTool
-
-
-def get_publisher_tools() -> Tuple[List[FunctionTool], str, str]:
-    tools = []
-    # Get configured tools from the tools.yaml file
-    configured_tools = ToolFactory.from_env(map_result=True)
-    if "generate_document" in configured_tools.keys():
-        tools.append(configured_tools["generate_document"])
-        prompt_instructions = dedent("""
-            Normally, reply the blog post content to the user directly. 
-            But if user requested to generate a file, use the generate_document tool to generate the file and reply the link to the file.
-        """)
-        description = "Expert in publishing the blog post, able to publish the blog post in PDF or HTML format."
-    else:
-        prompt_instructions = "You don't have a tool to generate document. Please reply the content directly."
-        description = "Expert in publishing the blog post"
-    return tools, prompt_instructions, description
-
-
-def create_publisher(chat_history: List[ChatMessage]):
-    tools, prompt_instructions, description = get_publisher_tools()
-    return FunctionCallingAgent(
-        name="publisher",
-        tools=tools,
-        description=description,
-        system_prompt=prompt_instructions,
-        chat_history=chat_history,
-    )

packages/create-llama/templates/components/agents/python/blog/app/agents/researcher.py

@@ -1,71 +0,0 @@
-from textwrap import dedent
-from typing import List
-
-from app.engine.index import IndexConfig, get_index
-from app.engine.tools import ToolFactory
-from app.workflows.single import FunctionCallingAgent
-from llama_index.core.chat_engine.types import ChatMessage
-from app.engine.tools.query_engine import get_query_engine_tool
-
-
-def _get_research_tools(**kwargs):
-    """
-    Researcher take responsibility for retrieving information.
-    Try init wikipedia or duckduckgo tool if available.
-    """
-    tools = []
-    # Create query engine tool
-    index_config = IndexConfig(**kwargs)
-    index = get_index(index_config)
-    if index is not None:
-        query_engine_tool = get_query_engine_tool(index=index)
-        if query_engine_tool is not None:
-            tools.append(query_engine_tool)
-
-    # Create duckduckgo tool
-    researcher_tool_names = [
-        "duckduckgo_search",
-        "duckduckgo_image_search",
-        "wikipedia.WikipediaToolSpec",
-    ]
-    configured_tools = ToolFactory.from_env(map_result=True)
-    for tool_name, tool in configured_tools.items():
-        if tool_name in researcher_tool_names:
-            tools.append(tool)
-    return tools
-
-
-def create_researcher(chat_history: List[ChatMessage], **kwargs):
-    """
-    Researcher is an agent that take responsibility for using tools to complete a given task.
-    """
-    tools = _get_research_tools(**kwargs)
-    return FunctionCallingAgent(
-        name="researcher",
-        tools=tools,
-        description="expert in retrieving any unknown content or searching for images from the internet",
-        system_prompt=dedent(
-            """
-            You are a researcher agent. You are given a research task.
-            
-            If the conversation already includes the information and there is no new request for additional information from the user, you should return the appropriate content to the writer.
-            Otherwise, you must use tools to retrieve information or images needed for the task.
-
-            It's normal for the task to include some ambiguity. You must always think carefully about the context of the user's request to understand what are the main content needs to be retrieved.
-            Example:
-                Request: "Create a blog post about the history of the internet, write in English and publish in PDF format."
-                ->Though: The main content is "history of the internet", while "write in English and publish in PDF format" is a requirement for other agents.
-                Your task: Look for information in English about the history of the Internet.
-                This is not your task: Create a blog post or look for how to create a PDF.
-
-                Next request: "Publish the blog post in HTML format."
-                ->Though: User just asking for a format change, the previous content is still valid.
-                Your task: Return the previous content of the post to the writer. No need to do any research.
-                This is not your task: Look for how to create an HTML file.
-
-            If you use the tools but don't find any related information, please return "I didn't find any new information for {the topic}." along with the content you found. Don't try to make up information yourself.
-            If the request doesn't need any new information because it was in the conversation history, please return "The task doesn't need any new information. Please reuse the existing content in the conversation history."
-        """
-        ),
-        chat_history=chat_history,
-    )

packages/create-llama/templates/components/agents/python/blog/app/agents/workflow.py

@@ -1,267 +0,0 @@
-from textwrap import dedent
-from typing import AsyncGenerator, List, Optional
-
-from app.agents.publisher import create_publisher
-from app.agents.researcher import create_researcher
-from app.workflows.single import AgentRunEvent, AgentRunResult, FunctionCallingAgent
-from llama_index.core.chat_engine.types import ChatMessage
-from llama_index.core.prompts import PromptTemplate
-from llama_index.core.settings import Settings
-from llama_index.core.workflow import (
-    Context,
-    Event,
-    StartEvent,
-    StopEvent,
-    Workflow,
-    step,
-)
-
-
-def create_workflow(chat_history: Optional[List[ChatMessage]] = None, **kwargs):
-    researcher = create_researcher(
-        chat_history=chat_history,
-        **kwargs,
-    )
-    publisher = create_publisher(
-        chat_history=chat_history,
-    )
-    writer = FunctionCallingAgent(
-        name="writer",
-        description="expert in writing blog posts, need information and images to write a post.",
-        system_prompt=dedent(
-            """
-            You are an expert in writing blog posts.
-            You are given the task of writing a blog post based on research content provided by the researcher agent. Do not invent any information yourself. 
-            It's important to read the entire conversation history to write the blog post accurately.
-            If you receive a review from the reviewer, update the post according to the feedback and return the new post content.
-            If the content is not valid (e.g., broken link, broken image, etc.), do not use it.
-            It's normal for the task to include some ambiguity, so you must define the user's initial request to write the post correctly.
-            If you update the post based on the reviewer's feedback, first explain what changes you made to the post, then provide the new post content. Do not include the reviewer's comments.
-            Example:
-                Task: "Here is the information I found about the history of the internet: 
-                Create a blog post about the history of the internet, write in English, and publish in PDF format."
-                -> Your task: Use the research content {...} to write a blog post in English.
-                -> This is not your task: Create a PDF
-                Please note that a localhost link is acceptable, but dummy links like "example.com" or "your-website.com" are not valid.
-        """
-        ),
-        chat_history=chat_history,
-    )
-    reviewer = FunctionCallingAgent(
-        name="reviewer",
-        description="expert in reviewing blog posts, needs a written blog post to review.",
-        system_prompt=dedent(
-            """
-            You are an expert in reviewing blog posts.
-            You are given a task to review a blog post. As a reviewer, it's important that your review aligns with the user's request. Please focus on the user's request when reviewing the post.
-            Review the post for logical inconsistencies, ask critical questions, and provide suggestions for improvement.
-            Furthermore, proofread the post for grammar and spelling errors.
-            Only if the post is good enough for publishing should you return 'The post is good.' In all other cases, return your review.
-            It's normal for the task to include some ambiguity, so you must define the user's initial request to review the post correctly.
-            Please note that a localhost link is acceptable, but dummy links like "example.com" or "your-website.com" are not valid.
-            Example:
-                Task: "Create a blog post about the history of the internet, write in English and publish in PDF format."
-                -> Your task: Review whether the main content of the post is about the history of the internet and if it is written in English.
-                -> This is not your task: Create blog post, create PDF, write in English.
-        """
-        ),
-        chat_history=chat_history,
-    )
-    workflow = BlogPostWorkflow(
-        timeout=360, chat_history=chat_history
-    )  # Pass chat_history here
-    workflow.add_workflows(
-        researcher=researcher,
-        writer=writer,
-        reviewer=reviewer,
-        publisher=publisher,
-    )
-    return workflow
-
-
-class ResearchEvent(Event):
-    input: str
-
-
-class WriteEvent(Event):
-    input: str
-    is_good: bool = False
-
-
-class ReviewEvent(Event):
-    input: str
-
-
-class PublishEvent(Event):
-    input: str
-
-
-class BlogPostWorkflow(Workflow):
-    def __init__(
-        self, timeout: int = 360, chat_history: Optional[List[ChatMessage]] = None
-    ):
-        super().__init__(timeout=timeout)
-        self.chat_history = chat_history or []
-
-    @step()
-    async def start(self, ctx: Context, ev: StartEvent) -> ResearchEvent | PublishEvent:
-        # set streaming
-        ctx.data["streaming"] = getattr(ev, "streaming", False)
-        # start the workflow with researching about a topic
-        ctx.data["task"] = ev.input
-        ctx.data["user_input"] = ev.input
-
-        # Decision-making process
-        decision = await self._decide_workflow(ev.input, self.chat_history)
-
-        if decision != "publish":
-            return ResearchEvent(input=f"Research for this task: {ev.input}")
-        else:
-            chat_history_str = "\n".join(
-                [f"{msg.role}: {msg.content}" for msg in self.chat_history]
-            )
-            return PublishEvent(
-                input=f"Please publish content based on the chat history\n{chat_history_str}\n\n and task: {ev.input}"
-            )
-
-    async def _decide_workflow(
-        self, input: str, chat_history: List[ChatMessage]
-    ) -> str:
-        prompt_template = PromptTemplate(
-            dedent(
-                """
-                You are an expert in decision-making, helping people write and publish blog posts.
-                If the user is asking for a file or to publish content, respond with 'publish'.
-                If the user requests to write or update a blog post, respond with 'not_publish'.
-
-                Here is the chat history:
-                {chat_history}
-
-                The current user request is:
-                {input}
-
-                Given the chat history and the new user request, decide whether to publish based on existing information.
-                Decision (respond with either 'not_publish' or 'publish'):
-            """
-            )
-        )
-
-        chat_history_str = "\n".join(
-            [f"{msg.role}: {msg.content}" for msg in chat_history]
-        )
-        prompt = prompt_template.format(chat_history=chat_history_str, input=input)
-
-        output = await Settings.llm.acomplete(prompt)
-        decision = output.text.strip().lower()
-
-        return "publish" if decision == "publish" else "research"
-
-    @step()
-    async def research(
-        self, ctx: Context, ev: ResearchEvent, researcher: FunctionCallingAgent
-    ) -> WriteEvent:
-        result: AgentRunResult = await self.run_agent(ctx, researcher, ev.input)
-        content = result.response.message.content
-        return WriteEvent(
-            input=f"Write a blog post given this task: {ctx.data['task']} using this research content: {content}"
-        )
-
-    @step()
-    async def write(
-        self, ctx: Context, ev: WriteEvent, writer: FunctionCallingAgent
-    ) -> ReviewEvent | StopEvent:
-        MAX_ATTEMPTS = 2
-        ctx.data["attempts"] = ctx.data.get("attempts", 0) + 1
-        too_many_attempts = ctx.data["attempts"] > MAX_ATTEMPTS
-        if too_many_attempts:
-            ctx.write_event_to_stream(
-                AgentRunEvent(
-                    name=writer.name,
-                    msg=f"Too many attempts ({MAX_ATTEMPTS}) to write the blog post. Proceeding with the current version.",
-                )
-            )
-        if ev.is_good or too_many_attempts:
-            # too many attempts or the blog post is good - stream final response if requested
-            result = await self.run_agent(
-                ctx,
-                writer,
-                f"Based on the reviewer's feedback, refine the post and return only the final version of the post. Here's the current version: {ev.input}",
-                streaming=ctx.data["streaming"],
-            )
-            return StopEvent(result=result)
-        result: AgentRunResult = await self.run_agent(ctx, writer, ev.input)
-        ctx.data["result"] = result
-        return ReviewEvent(input=result.response.message.content)
-
-    @step()
-    async def review(
-        self, ctx: Context, ev: ReviewEvent, reviewer: FunctionCallingAgent
-    ) -> WriteEvent:
-        result: AgentRunResult = await self.run_agent(ctx, reviewer, ev.input)
-        review = result.response.message.content
-        old_content = ctx.data["result"].response.message.content
-        post_is_good = "post is good" in review.lower()
-        ctx.write_event_to_stream(
-            AgentRunEvent(
-                name=reviewer.name,
-                msg=f"The post is {'not ' if not post_is_good else ''}good enough for publishing. Sending back to the writer{' for publication.' if post_is_good else '.'}",
-            )
-        )
-        if post_is_good:
-            return WriteEvent(
-                input=f"You're blog post is ready for publication. Please respond with just the blog post. Blog post: ```{old_content}```",
-                is_good=True,
-            )
-        else:
-            return WriteEvent(
-                input=dedent(
-                    f"""
-                    Improve the writing of a given blog post by using a given review.
-                    Blog post:
-                    ```
-                    {old_content}
-                    ``` 
-
-                    Review: 
-                    ```
-                    {review}
-                    ```
-                    """
-                ),
-            )
-
-    @step()
-    async def publish(
-        self,
-        ctx: Context,
-        ev: PublishEvent,
-        publisher: FunctionCallingAgent,
-    ) -> StopEvent:
-        try:
-            result: AgentRunResult = await self.run_agent(
-                ctx, publisher, ev.input, streaming=ctx.data["streaming"]
-            )
-            return StopEvent(result=result)
-        except Exception as e:
-            ctx.write_event_to_stream(
-                AgentRunEvent(
-                    name=publisher.name,
-                    msg=f"Error publishing: {e}",
-                )
-            )
-            return StopEvent(result=None)
-
-    async def run_agent(
-        self,
-        ctx: Context,
-        agent: FunctionCallingAgent,
-        input: str,
-        streaming: bool = False,
-    ) -> AgentRunResult | AsyncGenerator:
-        handler = agent.run(input=input, streaming=streaming)
-        # bubble all events while running the executor to the planner
-        async for event in handler.stream_events():
-            # Don't write the StopEvent from sub task to the stream
-            if type(event) is not StopEvent:
-                ctx.write_event_to_stream(event)
-        return await handler

packages/create-llama/templates/components/agents/python/blog/app/workflows/__init__.py

@@ -1,3 +0,0 @@
-from .blog import create_workflow
-
-__all__ = ["create_workflow"]

packages/create-llama/templates/components/agents/python/blog/app/workflows/blog.py

@@ -1,30 +0,0 @@
-import logging
-import os
-from typing import List, Optional
-
-from app.agents.choreography import create_choreography
-from app.agents.orchestrator import create_orchestrator
-from app.agents.workflow import create_workflow as create_blog_workflow
-from llama_index.core.chat_engine.types import ChatMessage
-from llama_index.core.workflow import Workflow
-
-logger = logging.getLogger("uvicorn")
-
-
-def create_workflow(
-    chat_history: Optional[List[ChatMessage]] = None, **kwargs
-) -> Workflow:
-    # Chat filters are not supported yet
-    kwargs.pop("filters", None)
-    agent_type = os.getenv("EXAMPLE_TYPE", "").lower()
-    match agent_type:
-        case "choreography":
-            agent = create_choreography(chat_history, **kwargs)
-        case "orchestrator":
-            agent = create_orchestrator(chat_history, **kwargs)
-        case _:
-            agent = create_blog_workflow(chat_history, **kwargs)
-
-    logger.info(f"Using agent pattern: {agent_type}")
-
-    return agent

packages/create-llama/templates/components/agents/python/blog/app/workflows/multi.py

@@ -1,86 +0,0 @@
-from typing import Any, List
-
-from app.workflows.planner import StructuredPlannerAgent
-from app.workflows.single import (
-    AgentRunResult,
-    ContextAwareTool,
-    FunctionCallingAgent,
-)
-from llama_index.core.tools.types import ToolMetadata, ToolOutput
-from llama_index.core.tools.utils import create_schema_from_function
-from llama_index.core.workflow import Context, StopEvent, Workflow
-
-
-class AgentCallTool(ContextAwareTool):
-    def __init__(self, agent: Workflow) -> None:
-        self.agent = agent
-        name = f"call_{agent.name}"
-
-        async def schema_call(input: str) -> str:
-            pass
-
-        # create the schema without the Context
-        fn_schema = create_schema_from_function(name, schema_call)
-        self._metadata = ToolMetadata(
-            name=name,
-            description=(
-                f"Use this tool to delegate a sub task to the {agent.name} agent."
-                + (
-                    f" The agent is an {agent.description}."
-                    if agent.description
-                    else ""
-                )
-            ),
-            fn_schema=fn_schema,
-        )
-
-    # overload the acall function with the ctx argument as it's needed for bubbling the events
-    async def acall(self, ctx: Context, input: str) -> ToolOutput:
-        handler = self.agent.run(input=input)
-        # bubble all events while running the agent to the calling agent
-        async for ev in handler.stream_events():
-            if type(ev) is not StopEvent:
-                ctx.write_event_to_stream(ev)
-        ret: AgentRunResult = await handler
-        response = ret.response.message.content
-        return ToolOutput(
-            content=str(response),
-            tool_name=self.metadata.name,
-            raw_input={"args": input, "kwargs": {}},
-            raw_output=response,
-        )
-
-
-class AgentCallingAgent(FunctionCallingAgent):
-    def __init__(
-        self,
-        *args: Any,
-        name: str,
-        agents: List[FunctionCallingAgent] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        agents = agents or []
-        tools = [AgentCallTool(agent=agent) for agent in agents]
-        super().__init__(*args, name=name, tools=tools, **kwargs)
-        # call add_workflows so agents will get detected by llama agents automatically
-        self.add_workflows(**{agent.name: agent for agent in agents})
-
-
-class AgentOrchestrator(StructuredPlannerAgent):
-    def __init__(
-        self,
-        *args: Any,
-        name: str = "orchestrator",
-        agents: List[FunctionCallingAgent] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        agents = agents or []
-        tools = [AgentCallTool(agent=agent) for agent in agents]
-        super().__init__(
-            *args,
-            name=name,
-            tools=tools,
-            **kwargs,
-        )
-        # call add_workflows so agents will get detected by llama agents automatically
-        self.add_workflows(**{agent.name: agent for agent in agents})

packages/create-llama/templates/components/agents/python/blog/app/workflows/planner.py

@@ -1,347 +0,0 @@
-import uuid
-from enum import Enum
-from typing import Any, AsyncGenerator, Dict, List, Optional, Tuple, Union
-
-from app.workflows.single import AgentRunEvent, AgentRunResult, FunctionCallingAgent
-from llama_index.core.agent.runner.planner import (
-    DEFAULT_INITIAL_PLAN_PROMPT,
-    DEFAULT_PLAN_REFINE_PROMPT,
-    Plan,
-    PlannerAgentState,
-    SubTask,
-)
-from llama_index.core.bridge.pydantic import ValidationError
-from llama_index.core.chat_engine.types import ChatMessage
-from llama_index.core.llms.function_calling import FunctionCallingLLM
-from llama_index.core.prompts import PromptTemplate
-from llama_index.core.settings import Settings
-from llama_index.core.tools import BaseTool
-from llama_index.core.workflow import (
-    Context,
-    Event,
-    StartEvent,
-    StopEvent,
-    Workflow,
-    step,
-)
-
-INITIAL_PLANNER_PROMPT = """\
-Think step-by-step. Given a conversation, set of tools and a user request. Your responsibility is to create a plan to complete the task.
-The plan must adapt with the user request and the conversation.
-
-The tools available are:
-{tools_str}
-
-Conversation: {chat_history}
-
-Overall Task: {task}
-"""
-
-
-class ExecutePlanEvent(Event):
-    pass
-
-
-class SubTaskEvent(Event):
-    sub_task: SubTask
-
-
-class SubTaskResultEvent(Event):
-    sub_task: SubTask
-    result: AgentRunResult | AsyncGenerator
-
-
-class PlanEventType(Enum):
-    CREATED = "created"
-    REFINED = "refined"
-
-
-class PlanEvent(AgentRunEvent):
-    event_type: PlanEventType
-    plan: Plan
-
-    @property
-    def msg(self) -> str:
-        sub_task_names = ", ".join(task.name for task in self.plan.sub_tasks)
-        return f"Plan {self.event_type.value}: Let's do: {sub_task_names}"
-
-
-class StructuredPlannerAgent(Workflow):
-    def __init__(
-        self,
-        *args: Any,
-        name: str,
-        llm: FunctionCallingLLM | None = None,
-        tools: List[BaseTool] | None = None,
-        timeout: float = 360.0,
-        refine_plan: bool = False,
-        chat_history: Optional[List[ChatMessage]] = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(*args, timeout=timeout, **kwargs)
-        self.name = name
-        self.refine_plan = refine_plan
-        self.chat_history = chat_history
-
-        self.tools = tools or []
-        self.planner = Planner(
-            llm=llm,
-            tools=self.tools,
-            initial_plan_prompt=INITIAL_PLANNER_PROMPT,
-            verbose=self._verbose,
-        )
-        # The executor is keeping the memory of all tool calls and decides to call the right tool for the task
-        self.executor = FunctionCallingAgent(
-            name="executor",
-            llm=llm,
-            tools=self.tools,
-            write_events=False,
-            # it's important to instruct to just return the tool call, otherwise the executor will interpret and change the result
-            system_prompt="You are an expert in completing given tasks by calling the right tool for the task. Just return the result of the tool call. Don't add any information yourself",
-        )
-        self.add_workflows(executor=self.executor)
-
-    @step()
-    async def create_plan(
-        self, ctx: Context, ev: StartEvent
-    ) -> ExecutePlanEvent | StopEvent:
-        # set streaming
-        ctx.data["streaming"] = getattr(ev, "streaming", False)
-        ctx.data["task"] = ev.input
-
-        plan_id, plan = await self.planner.create_plan(
-            input=ev.input, chat_history=self.chat_history
-        )
-        ctx.data["act_plan_id"] = plan_id
-
-        # inform about the new plan
-        ctx.write_event_to_stream(
-            PlanEvent(name=self.name, event_type=PlanEventType.CREATED, plan=plan)
-        )
-        if self._verbose:
-            print("=== Executing plan ===\n")
-        return ExecutePlanEvent()
-
-    @step()
-    async def execute_plan(self, ctx: Context, ev: ExecutePlanEvent) -> SubTaskEvent:
-        upcoming_sub_tasks = self.planner.state.get_next_sub_tasks(
-            ctx.data["act_plan_id"]
-        )
-
-        if upcoming_sub_tasks:
-            # Execute only the first sub-task
-            # otherwise the executor will get over-lapping messages
-            # alternatively, we could use one executor for all sub tasks
-            next_sub_task = upcoming_sub_tasks[0]
-            return SubTaskEvent(sub_task=next_sub_task)
-
-        return None
-
-    @step()
-    async def execute_sub_task(
-        self, ctx: Context, ev: SubTaskEvent
-    ) -> SubTaskResultEvent:
-        if self._verbose:
-            print(f"=== Executing sub task: {ev.sub_task.name} ===")
-        is_last_tasks = self.get_remaining_subtasks(ctx) == 1
-        # TODO: streaming only works without plan refining
-        streaming = is_last_tasks and ctx.data["streaming"] and not self.refine_plan
-        handler = self.executor.run(
-            input=ev.sub_task.input,
-            streaming=streaming,
-        )
-        # bubble all events while running the executor to the planner
-        async for event in handler.stream_events():
-            # Don't write the StopEvent from sub task to the stream
-            if type(event) is not StopEvent:
-                ctx.write_event_to_stream(event)
-        result: AgentRunResult = await handler
-        if self._verbose:
-            print("=== Done executing sub task ===\n")
-        self.planner.state.add_completed_sub_task(ctx.data["act_plan_id"], ev.sub_task)
-        return SubTaskResultEvent(sub_task=ev.sub_task, result=result)
-
-    @step()
-    async def gather_results(
-        self, ctx: Context, ev: SubTaskResultEvent
-    ) -> ExecutePlanEvent | StopEvent:
-        result = ev
-
-        upcoming_sub_tasks = self.get_upcoming_sub_tasks(ctx)
-        # if no more tasks to do, stop workflow and send result of last step
-        if upcoming_sub_tasks == 0:
-            return StopEvent(result=result.result)
-
-        if self.refine_plan:
-            # store the result for refining the plan
-            ctx.data["results"] = ctx.data.get("results", {})
-            ctx.data["results"][result.sub_task.name] = result.result
-
-            new_plan = await self.planner.refine_plan(
-                ctx.data["task"], ctx.data["act_plan_id"], ctx.data["results"]
-            )
-            # inform about the new plan
-            if new_plan is not None:
-                ctx.write_event_to_stream(
-                    PlanEvent(
-                        name=self.name, event_type=PlanEventType.REFINED, plan=new_plan
-                    )
-                )
-
-        # continue executing plan
-        return ExecutePlanEvent()
-
-    def get_upcoming_sub_tasks(self, ctx: Context):
-        upcoming_sub_tasks = self.planner.state.get_next_sub_tasks(
-            ctx.data["act_plan_id"]
-        )
-        return len(upcoming_sub_tasks)
-
-    def get_remaining_subtasks(self, ctx: Context):
-        remaining_subtasks = self.planner.state.get_remaining_subtasks(
-            ctx.data["act_plan_id"]
-        )
-        return len(remaining_subtasks)
-
-
-# Concern dealing with creating and refining a plan, extracted from https://github.com/run-llama/llama_index/blob/main/llama-index-core/llama_index/core/agent/runner/planner.py#L138
-class Planner:
-    def __init__(
-        self,
-        llm: FunctionCallingLLM | None = None,
-        tools: List[BaseTool] | None = None,
-        initial_plan_prompt: Union[str, PromptTemplate] = DEFAULT_INITIAL_PLAN_PROMPT,
-        plan_refine_prompt: Union[str, PromptTemplate] = DEFAULT_PLAN_REFINE_PROMPT,
-        verbose: bool = True,
-    ) -> None:
-        if llm is None:
-            llm = Settings.llm
-        self.llm = llm
-        assert self.llm.metadata.is_function_calling_model
-
-        self.tools = tools or []
-        self.state = PlannerAgentState()
-        self.verbose = verbose
-
-        if isinstance(initial_plan_prompt, str):
-            initial_plan_prompt = PromptTemplate(initial_plan_prompt)
-        self.initial_plan_prompt = initial_plan_prompt
-
-        if isinstance(plan_refine_prompt, str):
-            plan_refine_prompt = PromptTemplate(plan_refine_prompt)
-        self.plan_refine_prompt = plan_refine_prompt
-
-    async def create_plan(
-        self, input: str, chat_history: Optional[List[ChatMessage]] = None
-    ) -> Tuple[str, Plan]:
-        tools = self.tools
-        tools_str = ""
-        for tool in tools:
-            tools_str += tool.metadata.name + ": " + tool.metadata.description + "\n"
-
-        try:
-            plan = await self.llm.astructured_predict(
-                Plan,
-                self.initial_plan_prompt,
-                tools_str=tools_str,
-                task=input,
-                chat_history=chat_history,
-            )
-        except (ValueError, ValidationError):
-            if self.verbose:
-                print("No complex plan predicted. Defaulting to a single task plan.")
-            plan = Plan(
-                sub_tasks=[
-                    SubTask(
-                        name="default", input=input, expected_output="", dependencies=[]
-                    )
-                ]
-            )
-
-        if self.verbose:
-            print("=== Initial plan ===")
-            for sub_task in plan.sub_tasks:
-                print(
-                    f"{sub_task.name}:\n{sub_task.input} -> {sub_task.expected_output}\ndeps: {sub_task.dependencies}\n\n"
-                )
-
-        plan_id = str(uuid.uuid4())
-        self.state.plan_dict[plan_id] = plan
-
-        return plan_id, plan
-
-    async def refine_plan(
-        self,
-        input: str,
-        plan_id: str,
-        completed_sub_tasks: Dict[str, str],
-    ) -> Optional[Plan]:
-        """Refine a plan."""
-        prompt_args = self.get_refine_plan_prompt_kwargs(
-            plan_id, input, completed_sub_tasks
-        )
-
-        try:
-            new_plan = await self.llm.astructured_predict(
-                Plan, self.plan_refine_prompt, **prompt_args
-            )
-
-            self._update_plan(plan_id, new_plan)
-
-            return new_plan
-        except (ValueError, ValidationError) as e:
-            # likely no new plan predicted
-            if self.verbose:
-                print(f"No new plan predicted: {e}")
-            return None
-
-    def _update_plan(self, plan_id: str, new_plan: Plan) -> None:
-        """Update the plan."""
-        # update state with new plan
-        self.state.plan_dict[plan_id] = new_plan
-
-        if self.verbose:
-            print("=== Refined plan ===")
-            for sub_task in new_plan.sub_tasks:
-                print(
-                    f"{sub_task.name}:\n{sub_task.input} -> {sub_task.expected_output}\ndeps: {sub_task.dependencies}\n\n"
-                )
-
-    def get_refine_plan_prompt_kwargs(
-        self,
-        plan_id: str,
-        task: str,
-        completed_sub_task: Dict[str, str],
-    ) -> dict:
-        """Get the refine plan prompt."""
-        # gather completed sub-tasks and response pairs
-        completed_outputs_str = ""
-        for sub_task_name, task_output in completed_sub_task.items():
-            task_str = f"{sub_task_name}:\n\t{task_output!s}\n"
-            completed_outputs_str += task_str
-
-        # get a string for the remaining sub-tasks
-        remaining_sub_tasks = self.state.get_remaining_subtasks(plan_id)
-        remaining_sub_tasks_str = "" if len(remaining_sub_tasks) != 0 else "None"
-        for sub_task in remaining_sub_tasks:
-            task_str = (
-                f"SubTask(name='{sub_task.name}', "
-                f"input='{sub_task.input}', "
-                f"expected_output='{sub_task.expected_output}', "
-                f"dependencies='{sub_task.dependencies}')\n"
-            )
-            remaining_sub_tasks_str += task_str
-
-        # get the tools string
-        tools = self.tools
-        tools_str = ""
-        for tool in tools:
-            tools_str += tool.metadata.name + ": " + tool.metadata.description + "\n"
-
-        # return the kwargs
-        return {
-            "tools_str": tools_str.strip(),
-            "task": task.strip(),
-            "completed_outputs": completed_outputs_str.strip(),
-            "remaining_sub_tasks": remaining_sub_tasks_str.strip(),
-        }

packages/create-llama/templates/components/agents/python/blog/app/workflows/single.py

@@ -1,254 +0,0 @@
-from abc import abstractmethod
-from enum import Enum
-from typing import Any, AsyncGenerator, List, Optional
-
-from llama_index.core.llms import ChatMessage, ChatResponse
-from llama_index.core.llms.function_calling import FunctionCallingLLM
-from llama_index.core.memory import ChatMemoryBuffer
-from llama_index.core.settings import Settings
-from llama_index.core.tools import FunctionTool, ToolOutput, ToolSelection
-from llama_index.core.tools.types import BaseTool
-from llama_index.core.workflow import (
-    Context,
-    Event,
-    StartEvent,
-    StopEvent,
-    Workflow,
-    step,
-)
-from pydantic import BaseModel, Field
-
-
-class InputEvent(Event):
-    input: list[ChatMessage]
-
-
-class ToolCallEvent(Event):
-    tool_calls: list[ToolSelection]
-
-
-class AgentRunEventType(Enum):
-    TEXT = "text"
-    PROGRESS = "progress"
-
-
-class AgentRunEvent(Event):
-    name: str
-    msg: str
-    event_type: AgentRunEventType = Field(default=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 AgentRunResult(BaseModel):
-    response: ChatResponse
-    sources: list[ToolOutput]
-
-
-class ContextAwareTool(FunctionTool):
-    @abstractmethod
-    async def acall(self, ctx: Context, input: Any) -> ToolOutput:
-        pass
-
-
-class FunctionCallingAgent(Workflow):
-    def __init__(
-        self,
-        *args: Any,
-        llm: FunctionCallingLLM | None = None,
-        chat_history: Optional[List[ChatMessage]] = None,
-        tools: List[BaseTool] | None = None,
-        system_prompt: str | None = None,
-        verbose: bool = False,
-        timeout: float = 360.0,
-        name: str,
-        write_events: bool = True,
-        description: str | None = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(*args, verbose=verbose, timeout=timeout, **kwargs)
-        self.tools = tools or []
-        self.name = name
-        self.write_events = write_events
-        self.description = description
-
-        if llm is None:
-            llm = Settings.llm
-        self.llm = llm
-        assert self.llm.metadata.is_function_calling_model
-
-        self.system_prompt = system_prompt
-
-        self.memory = ChatMemoryBuffer.from_defaults(
-            llm=self.llm, chat_history=chat_history
-        )
-        self.sources = []
-
-    @step()
-    async def prepare_chat_history(self, ctx: Context, ev: StartEvent) -> InputEvent:
-        # clear sources
-        self.sources = []
-
-        # set system prompt
-        if self.system_prompt is not None:
-            system_msg = ChatMessage(role="system", content=self.system_prompt)
-            self.memory.put(system_msg)
-
-        # set streaming
-        ctx.data["streaming"] = getattr(ev, "streaming", False)
-
-        # get user input
-        user_input = ev.input
-        user_msg = ChatMessage(role="user", content=user_input)
-        self.memory.put(user_msg)
-        if self.write_events:
-            ctx.write_event_to_stream(
-                AgentRunEvent(name=self.name, msg=f"Start to work on: {user_input}")
-            )
-
-        # get chat history
-        chat_history = self.memory.get()
-        return InputEvent(input=chat_history)
-
-    @step()
-    async def handle_llm_input(
-        self, ctx: Context, ev: InputEvent
-    ) -> ToolCallEvent | StopEvent:
-        if ctx.data["streaming"]:
-            return await self.handle_llm_input_stream(ctx, ev)
-
-        chat_history = ev.input
-
-        response = await self.llm.achat_with_tools(
-            self.tools, chat_history=chat_history
-        )
-        self.memory.put(response.message)
-
-        tool_calls = self.llm.get_tool_calls_from_response(
-            response, error_on_no_tool_call=False
-        )
-
-        if not tool_calls:
-            if self.write_events:
-                ctx.write_event_to_stream(
-                    AgentRunEvent(name=self.name, msg="Finished task")
-                )
-            return StopEvent(
-                result=AgentRunResult(response=response, sources=[*self.sources])
-            )
-        else:
-            return ToolCallEvent(tool_calls=tool_calls)
-
-    async def handle_llm_input_stream(
-        self, ctx: Context, ev: InputEvent
-    ) -> ToolCallEvent | StopEvent:
-        chat_history = ev.input
-
-        async def response_generator() -> AsyncGenerator:
-            response_stream = await self.llm.astream_chat_with_tools(
-                self.tools, chat_history=chat_history
-            )
-
-            full_response = None
-            yielded_indicator = False
-            async for chunk in response_stream:
-                if "tool_calls" not in chunk.message.additional_kwargs:
-                    # Yield a boolean to indicate whether the response is a tool call
-                    if not yielded_indicator:
-                        yield False
-                        yielded_indicator = True
-
-                    # if not a tool call, yield the chunks!
-                    yield chunk
-                elif not yielded_indicator:
-                    # Yield the indicator for a tool call
-                    yield True
-                    yielded_indicator = True
-
-                full_response = chunk
-
-            # Write the full response to memory
-            self.memory.put(full_response.message)
-
-            # Yield the final response
-            yield full_response
-
-        # Start the generator
-        generator = response_generator()
-
-        # Check for immediate tool call
-        is_tool_call = await generator.__anext__()
-        if is_tool_call:
-            full_response = await generator.__anext__()
-            tool_calls = self.llm.get_tool_calls_from_response(full_response)
-            return ToolCallEvent(tool_calls=tool_calls)
-
-        # If we've reached here, it's not an immediate tool call, so we return the generator
-        if self.write_events:
-            ctx.write_event_to_stream(
-                AgentRunEvent(name=self.name, msg="Finished task")
-            )
-        return StopEvent(result=generator)
-
-    @step()
-    async def handle_tool_calls(self, ctx: Context, ev: ToolCallEvent) -> InputEvent:
-        tool_calls = ev.tool_calls
-        tools_by_name = {tool.metadata.get_name(): tool for tool in self.tools}
-
-        tool_msgs = []
-
-        # call tools -- safely!
-        for tool_call in tool_calls:
-            tool = tools_by_name.get(tool_call.tool_name)
-            additional_kwargs = {
-                "tool_call_id": tool_call.tool_id,
-                "name": tool.metadata.get_name(),
-            }
-            if not tool:
-                tool_msgs.append(
-                    ChatMessage(
-                        role="tool",
-                        content=f"Tool {tool_call.tool_name} does not exist",
-                        additional_kwargs=additional_kwargs,
-                    )
-                )
-                continue
-
-            try:
-                if isinstance(tool, ContextAwareTool):
-                    # inject context for calling an context aware tool
-                    tool_output = await tool.acall(ctx=ctx, **tool_call.tool_kwargs)
-                else:
-                    tool_output = await tool.acall(**tool_call.tool_kwargs)
-                self.sources.append(tool_output)
-                tool_msgs.append(
-                    ChatMessage(
-                        role="tool",
-                        content=tool_output.content,
-                        additional_kwargs=additional_kwargs,
-                    )
-                )
-            except Exception as e:
-                tool_msgs.append(
-                    ChatMessage(
-                        role="tool",
-                        content=f"Encountered error in tool call: {e}",
-                        additional_kwargs=additional_kwargs,
-                    )
-                )
-
-        for msg in tool_msgs:
-            self.memory.put(msg)
-
-        chat_history = self.memory.get()
-        return InputEvent(input=chat_history)

packages/create-llama/templates/components/agents/python/deep_research/README-template.md

@@ -1,47 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) multi-agents project using [Workflows](https://docs.llamaindex.ai/en/stable/understanding/workflows/).
-
-## Getting Started
-
-First, setup the environment with poetry:
-
-> **_Note:_** This step is not needed if you are using the dev-container.
-
-```shell
-uv sync
-```
-
-Then check the parameters that have been pre-configured in the `.env` file in this directory. (E.g. you might need to configure an `OPENAI_API_KEY` if you're using OpenAI as model provider).
-Second, generate the embeddings of the documents in the `./data` directory:
-
-```shell
-uv run generate
-```
-
-Third, run the development server:
-
-```shell
-uv run dev
-```
-
-## Use Case: Deep Research over own documents
-
-The workflow performs deep research by retrieving and analyzing documents from the [data](./data) directory from multiple perspectives. The project includes a sample PDF about AI investment in 2024 to help you get started. You can also add your own documents by placing them in the data directory and running the generate script again to index them.
-
-After starting the server, go to [http://localhost:8000](http://localhost:8000) and send a message to the agent to write a blog post.
-E.g: "AI investment in 2024"
-
-To update the workflow, you can edit the [deep_research.py](./app/workflows/deep_research.py) file.
-
-By default, the workflow retrieves 10 results from your documents. To customize the amount of information covered in the answer, you can adjust the `TOP_K` environment variable in the `.env` file. A higher value will retrieve more results from your documents, potentially providing more comprehensive answers.
-
-## Deployments
-
-For production deployments, check the [DEPLOY.md](DEPLOY.md) file.
-
-## Learn More
-
-To learn more about LlamaIndex, take a look at the following resources:
-
-- [LlamaIndex Documentation](https://docs.llamaindex.ai) - learn about LlamaIndex.
-- [Workflows Introduction](https://docs.llamaindex.ai/en/stable/understanding/workflows/) - learn about LlamaIndex workflows.
-  You can check out [the LlamaIndex GitHub repository](https://github.com/run-llama/llama_index) - your feedback and contributions are welcome!

packages/create-llama/templates/components/agents/python/deep_research/app/workflows/__init__.py

@@ -1,3 +0,0 @@
-from .deep_research import create_workflow
-
-__all__ = ["create_workflow"]

packages/create-llama/templates/components/agents/python/deep_research/app/workflows/agents.py

@@ -1,183 +0,0 @@
-from typing import List, Literal, Optional
-
-from llama_index.core.base.llms.types import (
-    CompletionResponse,
-    CompletionResponseAsyncGen,
-)
-from llama_index.core.memory.simple_composable_memory import SimpleComposableMemory
-from llama_index.core.prompts import PromptTemplate
-from llama_index.core.schema import MetadataMode, Node, NodeWithScore
-from llama_index.core.settings import Settings
-from pydantic import BaseModel, Field
-
-
-class AnalysisDecision(BaseModel):
-    decision: Literal["research", "write", "cancel"] = Field(
-        description="Whether to continue research, write a report, or cancel the research after several retries"
-    )
-    research_questions: Optional[List[str]] = Field(
-        description="""
-        If the decision is to research, provide a list of questions to research that related to the user request.
-        Maximum 3 questions. Set to null or empty if writing a report or cancel the research.
-        """,
-        default_factory=list,
-    )
-    cancel_reason: Optional[str] = Field(
-        description="The reason for cancellation if the decision is to cancel research.",
-        default=None,
-    )
-
-
-async def plan_research(
-    memory: SimpleComposableMemory,
-    context_nodes: List[Node],
-    user_request: str,
-    total_questions: int,
-) -> AnalysisDecision:
-    analyze_prompt = """
-      You are a professor who is guiding a researcher to research a specific request/problem.
-      Your task is to decide on a research plan for the researcher.
-
-      The possible actions are:
-      + Provide a list of questions for the researcher to investigate, with the purpose of clarifying the request.
-      + Write a report if the researcher has already gathered enough research on the topic and can resolve the initial request.
-      + Cancel the research if most of the answers from researchers indicate there is insufficient information to research the request. Do not attempt more than 3 research iterations or too many questions.
-
-      The workflow should be:
-      + Always begin by providing some initial questions for the researcher to investigate.
-      + Analyze the provided answers against the initial topic/request. If the answers are insufficient to resolve the initial request, provide additional questions for the researcher to investigate.
-      + If the answers are sufficient to resolve the initial request, instruct the researcher to write a report.
-
-      Here are the context: 
-      <Collected information>
-      {context_str}
-      </Collected information>
-
-      <Conversation context>
-      {conversation_context}
-      </Conversation context>
-
-      {enhanced_prompt}
-
-      Now, provide your decision in the required format for this user request:
-      <User request>
-      {user_request}
-      </User request>
-      """
-    # Manually craft the prompt to avoid LLM hallucination
-    enhanced_prompt = ""
-    if total_questions == 0:
-        # Avoid writing a report without any research context
-        enhanced_prompt = """
-        
-        The student has no questions to research. Let start by asking some questions.
-        """
-    elif total_questions > 6:
-        # Avoid asking too many questions (when the data is not ready for writing a report)
-        enhanced_prompt = f"""
-
-        The student has researched {total_questions} questions. Should cancel the research if the context is not enough to write a report.
-        """
-
-    conversation_context = "\n".join(
-        [f"{message.role}: {message.content}" for message in memory.get_all()]
-    )
-    context_str = "\n".join(
-        [node.get_content(metadata_mode=MetadataMode.LLM) for node in context_nodes]
-    )
-    res = await Settings.llm.astructured_predict(
-        output_cls=AnalysisDecision,
-        prompt=PromptTemplate(template=analyze_prompt),
-        user_request=user_request,
-        context_str=context_str,
-        conversation_context=conversation_context,
-        enhanced_prompt=enhanced_prompt,
-    )
-    return res
-
-
-async def research(
-    question: str,
-    context_nodes: List[NodeWithScore],
-) -> str:
-    prompt = """
-    You are a researcher who is in the process of answering the question.
-    The purpose is to answer the question based on the collected information, without using prior knowledge or making up any new information.
-    Always add citations to the sentence/point/paragraph using the id of the provided content.
-    The citation should follow this format: [citation:id]() where id is the id of the content.
-    
-    E.g:
-    If we have a context like this:
-    <Citation id='abc-xyz'>
-    Baby llama is called cria
-    </Citation id='abc-xyz'>
-
-    And your answer uses the content, then the citation should be:
-    - Baby llama is called cria [citation:abc-xyz]()
-
-    Here is the provided context for the question:
-    <Collected information>
-    {context_str}
-    </Collected information>`
-
-    No prior knowledge, just use the provided context to answer the question: {question}
-    """
-    context_str = "\n".join(
-        [_get_text_node_content_for_citation(node) for node in context_nodes]
-    )
-    res = await Settings.llm.acomplete(
-        prompt=prompt.format(question=question, context_str=context_str),
-    )
-    return res.text
-
-
-async def write_report(
-    memory: SimpleComposableMemory,
-    user_request: str,
-    stream: bool = False,
-) -> CompletionResponse | CompletionResponseAsyncGen:
-    report_prompt = """
-    You are a researcher writing a report based on a user request and the research context.
-    You have researched various perspectives related to the user request.
-    The report should provide a comprehensive outline covering all important points from the researched perspectives.
-    Create a well-structured outline for the research report that covers all the answers.
-
-    # IMPORTANT when writing in markdown format:
-    + Use tables or figures where appropriate to enhance presentation.
-    + Preserve all citation syntax (the `[citation:id]()` parts in the provided context). Keep these citations in the final report - no separate reference section is needed.
-    + Do not add links, a table of contents, or a references section to the report.
-
-    <User request>
-    {user_request}
-    </User request>
-
-    <Research context>
-    {research_context}
-    </Research context>
-
-    Now, write a report addressing the user request based on the research provided following the format and guidelines above.
-    """
-    research_context = "\n".join(
-        [f"{message.role}: {message.content}" for message in memory.get_all()]
-    )
-
-    llm_complete_func = (
-        Settings.llm.astream_complete if stream else Settings.llm.acomplete
-    )
-
-    res = await llm_complete_func(
-        prompt=report_prompt.format(
-            user_request=user_request,
-            research_context=research_context,
-        ),
-    )
-    return res
-
-
-def _get_text_node_content_for_citation(node: NodeWithScore) -> str:
-    """
-    Construct node content for LLM with citation flag.
-    """
-    node_id = node.node.node_id
-    content = f"<Citation id='{node_id}'>\n{node.get_content(metadata_mode=MetadataMode.LLM)}</Citation id='{node_id}'>"
-    return content