Release 0.2.2 (#638)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.eslintrc

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

.github/workflows/e2e.yml

@@ -1,12 +1,15 @@
-name: E2E Tests
+name: E2E Tests for create-llama package
 on:
   push:
     branches: [main]
+    paths-ignore:
+      - "python/llama-index-server/**"
+      - ".github/workflows/*llama_index_server.yml"
   pull_request:
     branches: [main]
-
-env:
-  POETRY_VERSION: "1.6.1"
+    paths-ignore:
+      - "python/llama-index-server/**"
+      - ".github/workflows/*llama_index_server.yml"
 
 jobs:
   e2e-python:
@@ -20,6 +23,7 @@ jobs:
         os: [macos-latest, windows-latest, ubuntu-22.04]
         frameworks: ["fastapi"]
         datasources: ["--no-files", "--example-file", "--llamacloud"]
+        template-types: ["streaming", "llamaindexserver"]
     defaults:
       run:
         shell: bash
@@ -32,10 +36,10 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
-      - name: Install Poetry
-        uses: snok/install-poetry@v1
-        with:
-          version: ${{ env.POETRY_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
 
@@ -50,15 +54,15 @@ jobs:
 
       - name: Install Playwright Browsers
         run: pnpm exec playwright install --with-deps
-        working-directory: .
+        working-directory: packages/create-llama
 
       - name: Build create-llama
         run: pnpm run build
-        working-directory: .
+        working-directory: packages/create-llama
 
       - name: Install
         run: pnpm run pack-install
-        working-directory: .
+        working-directory: packages/create-llama
 
       - name: Run Playwright tests for Python
         run: pnpm run e2e:python
@@ -67,13 +71,17 @@ jobs:
           LLAMA_CLOUD_API_KEY: ${{ secrets.LLAMA_CLOUD_API_KEY }}
           FRAMEWORK: ${{ matrix.frameworks }}
           DATASOURCE: ${{ matrix.datasources }}
-        working-directory: .
+          TEMPLATE_TYPE: ${{ matrix.template-types }}
+          PYTHONIOENCODING: utf-8
+          PYTHONLEGACYWINDOWSSTDIO: utf-8
+        working-directory: packages/create-llama
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         if: always()
         with:
-          name: playwright-report-python
-          path: ./playwright-report/
+          name: playwright-report-python-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.datasources }}-${{ matrix.template-types }}
+          path: packages/create-llama/playwright-report/
+          overwrite: true
           retention-days: 30
 
   e2e-typescript:
@@ -82,11 +90,12 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        node-version: [18, 20]
+        node-version: [20, 22]
         python-version: ["3.11"]
         os: [macos-latest, windows-latest, ubuntu-22.04]
-        frameworks: ["nextjs", "express"]
+        frameworks: ["nextjs"]
         datasources: ["--no-files", "--example-file", "--llamacloud"]
+        template-types: ["streaming", "llamaindexserver"]
     defaults:
       run:
         shell: bash
@@ -99,10 +108,10 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
-      - name: Install Poetry
-        uses: snok/install-poetry@v1
-        with:
-          version: ${{ env.POETRY_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
 
@@ -117,15 +126,30 @@ jobs:
 
       - name: Install Playwright Browsers
         run: pnpm exec playwright install --with-deps
-        working-directory: .
+        working-directory: packages/create-llama
 
       - name: Build create-llama
         run: pnpm run build
-        working-directory: .
+        working-directory: packages/create-llama
 
       - name: Install
         run: pnpm run pack-install
-        working-directory: .
+        working-directory: packages/create-llama
+
+      - name: Build server
+        run: pnpm run build
+        working-directory: packages/server
+
+      - name: Pack @llamaindex/server package
+        run: |
+          pnpm pack --pack-destination "${{ runner.temp }}"
+          if [ "${{ runner.os }}" == "Windows" ]; then
+            file=$(find "${{ runner.temp }}" -name "llamaindex-server-*.tgz" | head -n 1)
+            mv "$file" "${{ runner.temp }}/llamaindex-server.tgz"
+          else
+            mv ${{ runner.temp }}/llamaindex-server-*.tgz ${{ runner.temp }}/llamaindex-server.tgz
+          fi
+        working-directory: packages/server
 
       - name: Run Playwright tests for TypeScript
         run: pnpm run e2e:typescript
@@ -134,11 +158,14 @@ jobs:
           LLAMA_CLOUD_API_KEY: ${{ secrets.LLAMA_CLOUD_API_KEY }}
           FRAMEWORK: ${{ matrix.frameworks }}
           DATASOURCE: ${{ matrix.datasources }}
-        working-directory: .
+          TEMPLATE_TYPE: ${{ matrix.template-types }}
+          SERVER_PACKAGE_PATH: ${{ runner.temp }}/llamaindex-server.tgz
+        working-directory: packages/create-llama
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         if: always()
         with:
-          name: playwright-report-typescript
-          path: ./playwright-report/
+          name: playwright-report-typescript-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.datasources }}-node${{ matrix.node-version }}-${{ matrix.template-types }}
+          path: packages/create-llama/playwright-report/
+          overwrite: true
           retention-days: 30

.github/workflows/lint_on_push_or_pull.yml

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

.github/workflows/release_llama_index_server.yml

@@ -0,0 +1,138 @@
+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') &&
+      !contains(github.event.head_commit.message, 'Release: llama-index-server v')
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        shell: bash
+        run: uv sync --all-extras --dev
+
+      - 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
+        shell: bash
+        run: |
+          uvx --from=toml-cli toml set --toml-path=pyproject.toml project.version $(uvx --from=toml-cli toml get --toml-path=pyproject.toml project.version | awk -F. '{$NF = $NF + 1;}1' OFS=.)
+          git add pyproject.toml
+          git commit -m "chore(release): bump llama-index-server version to $(uvx --from=toml-cli toml get --toml-path=pyproject.toml project.version)"
+
+      - name: Get current version
+        id: get_version
+        shell: bash
+        run: |
+          version=$(uvx --from=toml-cli toml get --toml-path=pyproject.toml project.version)
+          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: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        shell: bash
+        run: uv sync --all-extras
+
+      - name: Get current version
+        id: get_version
+        shell: bash
+        run: |
+          version=$(uvx --from=toml-cli toml get --toml-path=pyproject.toml project.version)
+          echo "current_version=${version}" >> "$GITHUB_OUTPUT"
+
+      - name: Build package
+        shell: bash
+        run: uv build --no-sources
+
+      - name: Publish to PyPI
+        shell: bash
+        run: uv publish --token ${{ secrets.PYPI_TOKEN }}
+
+      - 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

@@ -0,0 +1,99 @@
+name: Build Package
+
+on:
+  pull_request:
+
+env:
+  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 uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        shell: bash
+        run: uv sync --all-extras --dev
+
+      - name: Run unit tests
+        shell: bash
+        run: uv 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 uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+
+      - name: Install dependencies
+        shell: bash
+        run: uv sync --all-extras --dev
+
+      - name: Run mypy
+        shell: bash
+        run: uv 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 uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+
+      - name: Install build package
+        shell: bash
+        run: uv sync --all-extras
+
+      - name: Test import
+        shell: bash
+        run: uv 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,9 +6,6 @@ node_modules
 .pnpm-store
 .pnp.js
 
-# testing
-coverage
-
 # next.js
 .next/
 out/
@@ -34,24 +31,9 @@ yarn-error.log*
 dist/
 lib/
 
-# e2e
-.cache
-test-results/
-playwright-report/
-blob-report/
-playwright/.cache/
-.tsbuildinfo
-e2e/cache
-
 # intellij
 **/.idea
 
-# Python
-.mypy_cache/
-
-# build artifacts
-create-llama-*.tgz
-
 # vscode
 .vscode
 !.vscode/settings.json

.husky/pre-commit

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

.prettierignore

@@ -1,6 +1,17 @@
-apps/docs/i18n
-apps/docs/docs/api
+node_modules/
 pnpm-lock.yaml
 lib/
 dist/
-.docusaurus/
+cache/
+build/
+.next/
+out/
+packages/server/server/
+**/playwright-report/
+**/test-results/
+
+# Python
+python/
+**/*.mypy_cache/**
+**/*.venv/**
+**/*.ruff_cache/**

README.md

@@ -55,7 +55,7 @@ Then re-start your app. Remember you'll need to re-run `generate` if you add new
 If you're using the Python backend, you can trigger indexing of your data by calling:
 
 ```bash
-poetry run generate
+uv run generate
 ```
 
 ## Customizing the AI models
@@ -106,28 +106,16 @@ Ok to proceed? (y) y
 You can also pass command line arguments to set up a new project
 non-interactively. For a list of the latest options, call `create-llama --help`.
 
-### Running in pro mode
-
-If you prefer more advanced customization options, you can run `create-llama` in pro mode using the `--pro` flag.
-
-In pro mode, instead of selecting a predefined use case, you'll be prompted to select each technical component of your project. This allows for greater flexibility in customizing your project, including:
-
-- **Vector Store**: Choose from a variety of vector stores for keeping your documents, including MongoDB, Pinecone, Weaviate, Qdrant and Chroma.
-- **Tools**: Choose from a variety of agent tools (functions called by the LLM), such as:
-  - Code Interpreter: Executes Python code in a secure Jupyter notebook environment
-  - Artifact Code Generator: Generates code artifacts that can be run in a sandbox
-  - OpenAPI Action: Facilitates requests to a provided OpenAPI schema
-  - Image Generator: Creates images based on text descriptions
-  - Web Search: Performs web searches to retrieve up-to-date information
-- **Data Sources**: Integrate various data sources into your chat application, including local files, websites, or database-retrieved data.
-- **Backend Options**: Besides using Next.js or FastAPI, you can also select to use Express for a more traditional Node.js application.
-- **Observability**: Choose from a variety of LLM observability tools, including LlamaTrace and Traceloop.
-
-Pro mode is ideal for developers who want fine-grained control over their project's configuration and are comfortable with more technical setup options.
-
 ## LlamaIndex Documentation
 
 - [TS/JS docs](https://ts.llamaindex.ai/)
 - [Python docs](https://docs.llamaindex.ai/en/stable/)
 
+## LlamaIndex Server
+
+The generated code is using the LlamaIndex Server, which serves LlamaIndex Workflows and Agent Workflows via an API server. See the following docs for more information:
+
+- [LlamaIndex Server For TypeScript](./packages/server/README.md)
+- [LlamaIndex Server For Python](./python/llama-index-server/README.md)
+
 Inspired by and adapted from [create-next-app](https://github.com/vercel/next.js/tree/canary/packages/create-next-app)

e2e/python/resolve_dependencies.spec.ts

@@ -1,237 +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,
-            externalPort: 8000,
-            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,
-            externalPort: 8000,
-            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,
-            externalPort: 8000,
-            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,
-            externalPort: 8000,
-            postInstallAction: "none",
-            templateUI: undefined,
-            appType: "--no-frontend",
-            llamaCloudProjectName: undefined,
-            llamaCloudIndexName: undefined,
-            observability,
-          },
-        });
-      });
-    }
-  });
-}
-
-async function createAndCheckLlamaProject({
-  options,
-}: {
-  options: RunCreateLlamaOptions;
-}): Promise<{ pyprojectPath: string; projectPath: string }> {
-  const result = await runCreateLlama(options);
-  const name = result.projectName;
-  const projectPath = path.join(options.cwd, name);
-
-  // Check if the app folder exists
-  expect(fs.existsSync(projectPath)).toBeTruthy();
-
-  // Check if pyproject.toml exists
-  const pyprojectPath = path.join(projectPath, "pyproject.toml");
-  expect(fs.existsSync(pyprojectPath)).toBeTruthy();
-
-  const env = {
-    ...process.env,
-    POETRY_VIRTUALENVS_IN_PROJECT: "true",
-  };
-
-  // Run poetry install
-  try {
-    const { stdout: installStdout, stderr: installStderr } = await execAsync(
-      "poetry install",
-      { cwd: projectPath, env },
-    );
-    console.log("poetry install stdout:", installStdout);
-    console.error("poetry install stderr:", installStderr);
-  } catch (error) {
-    console.error("Error running poetry install:", error);
-    throw error;
-  }
-
-  // Run poetry run mypy
-  try {
-    const { stdout: mypyStdout, stderr: mypyStderr } = await execAsync(
-      "poetry run mypy .",
-      { cwd: projectPath, env },
-    );
-    console.log("poetry run mypy stdout:", mypyStdout);
-    console.error("poetry run mypy stderr:", mypyStderr);
-  } catch (error) {
-    console.error("Error running mypy:", error);
-    throw error;
-  }
-
-  // If we reach this point without throwing an error, the test passes
-  expect(true).toBeTruthy();
-
-  return { pyprojectPath, projectPath };
-}

e2e/shared/extractor_template.spec.ts

@@ -1,63 +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 } 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";
-
-// The extractor template currently only works with FastAPI and files (and not on Windows)
-if (
-  process.platform !== "win32" &&
-  templateFramework === "fastapi" &&
-  dataSource === "--example-file"
-) {
-  test.describe("Test extractor template", async () => {
-    let frontendPort: number;
-    let backendPort: number;
-    let name: string;
-    let appProcess: ChildProcess;
-    let cwd: string;
-
-    // Create extractor app
-    test.beforeAll(async () => {
-      cwd = await createTestDir();
-      frontendPort = Math.floor(Math.random() * 10000) + 10000;
-      backendPort = frontendPort + 1;
-      const result = await runCreateLlama({
-        cwd,
-        templateType: "extractor",
-        templateFramework: "fastapi",
-        dataSource: "--example-file",
-        vectorDb: "none",
-        port: frontendPort,
-        externalPort: backendPort,
-        postInstallAction: "runApp",
-      });
-      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:${frontendPort}`);
-      await expect(page.getByText("Built by LlamaIndex")).toBeVisible({
-        timeout: 2000 * 60,
-      });
-    });
-  });
-}

e2e/typescript/resolve_dependencies.spec.ts

@@ -1,106 +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,
-      externalPort: 8000,
-      postInstallAction: "none",
-      templateUI: undefined,
-      appType: templateFramework === "nextjs" ? "" : "--no-frontend",
-      llamaCloudProjectName: undefined,
-      llamaCloudIndexName: undefined,
-      tools: undefined,
-      useLlamaParse: useLlamaParse,
-    });
-    const name = result.projectName;
-
-    // Check if the app folder exists
-    const appDir = path.join(cwd, name);
-    const dirExists = fs.existsSync(appDir);
-    expect(dirExists).toBeTruthy();
-
-    // Install dependencies using pnpm
-    try {
-      const { stderr: installStderr } = await execAsync(
-        "pnpm install --prefer-offline",
-        {
-          cwd: appDir,
-        },
-      );
-    } catch (error) {
-      console.error("Error installing dependencies:", error);
-      throw error;
-    }
-
-    // Run tsc type check and capture the output
-    try {
-      const { stdout, stderr } = await execAsync(
-        "pnpm exec tsc -b --diagnostics",
-        {
-          cwd: appDir,
-        },
-      );
-      // Check if there's any error output
-      expect(stderr).toBeFalsy();
-
-      // Log the stdout for debugging purposes
-      console.log("TypeScript type-check output:", stdout);
-    } catch (error) {
-      console.error("Error running tsc:", error);
-      throw error;
-    }
-  }
-});

eslint.config.mjs

@@ -0,0 +1,62 @@
+import eslint from "@eslint/js";
+import eslintConfigPrettier from "eslint-config-prettier";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  eslintConfigPrettier,
+  {
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: "module",
+      globals: {
+        ...globals.browser,
+        ...globals.node,
+      },
+    },
+  },
+  {
+    files: ["packages/create-llama/**"],
+    rules: {
+      "max-params": ["error", 4],
+      "prefer-const": "error",
+      "no-empty": "off",
+      "no-extra-boolean-cast": "off",
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-unused-vars": "off",
+      "@typescript-eslint/no-empty-object-type": "off",
+      "@typescript-eslint/no-wrapper-object-types": "off",
+      "@typescript-eslint/ban-ts-comment": "off",
+    },
+  },
+  {
+    files: ["packages/server/**"],
+    rules: {
+      "no-irregular-whitespace": "off",
+      "@typescript-eslint/no-unused-vars": "off",
+      "@typescript-eslint/no-explicit-any": [
+        "error",
+        {
+          ignoreRestArgs: true,
+        },
+      ],
+    },
+  },
+  {
+    ignores: [
+      "python/**",
+      "**/*.mypy_cache/**",
+      "**/*.venv/**",
+      "**/*.ruff_cache/**",
+      "**/dist/**",
+      "**/e2e/cache/**",
+      "**/lib/*",
+      "**/.next/**",
+      "**/out/**",
+      "**/node_modules/**",
+      "**/build/**",
+    ],
+  },
+);

helpers/run-app.ts

@@ -1,99 +0,0 @@
-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);
-    });
-};
-
-export function runReflexApp(
-  appPath: string,
-  frontendPort?: number,
-  backendPort?: number,
-) {
-  const commandArgs = ["run", "reflex", "run"];
-  if (frontendPort) {
-    commandArgs.push("--frontend-port", frontendPort.toString());
-  }
-  if (backendPort) {
-    commandArgs.push("--backend-port", backendPort.toString());
-  }
-  return createProcess("poetry", commandArgs, {
-    stdio: "inherit",
-    cwd: appPath,
-  });
-}
-
-export function runFastAPIApp(appPath: string, port: number) {
-  const commandArgs = ["run", "uvicorn", "main:app", "--port=" + port];
-
-  return createProcess("poetry", commandArgs, {
-    stdio: "inherit",
-    cwd: appPath,
-  });
-}
-
-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: string,
-  frontend: boolean,
-  framework: TemplateFramework,
-  port?: number,
-  externalPort?: number,
-): Promise<any> {
-  const processes: ChildProcess[] = [];
-
-  // Callback to kill all sub processes if the main process is killed
-  process.on("exit", () => {
-    console.log("Killing app processes...");
-    processes.forEach((p) => p.kill());
-  });
-
-  // Default sub app paths
-  const backendPath = path.join(appPath, "backend");
-  const frontendPath = path.join(appPath, "frontend");
-
-  if (template === "extractor") {
-    processes.push(runReflexApp(appPath, port, externalPort));
-  }
-  if (template === "streaming" || template === "multiagent") {
-    if (framework === "fastapi" || framework === "express") {
-      const backendRunner = framework === "fastapi" ? runFastAPIApp : runTSApp;
-      if (frontend) {
-        processes.push(backendRunner(backendPath, externalPort || 8000));
-        processes.push(runTSApp(frontendPath, port || 3000));
-      } else {
-        processes.push(backendRunner(appPath, externalPort || 8000));
-      }
-    } else if (framework === "nextjs") {
-      processes.push(runTSApp(appPath, port || 3000));
-    }
-  }
-
-  return Promise.all(processes);
-}

package.json

@@ -1,83 +1,52 @@
 {
-  "name": "create-llama",
-  "version": "0.3.12",
-  "description": "Create LlamaIndex-powered apps with one command",
+  "name": "create-llama-monorepo",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Monorepo for create-llama",
   "keywords": [
     "rag",
-    "llamaindex",
-    "next.js"
+    "llamaindex"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/run-llama/create-llama",
-    "directory": "packages/create-llama"
+    "url": "https://github.com/run-llama/create-llama"
   },
   "license": "MIT",
-  "bin": {
-    "create-llama": "./dist/index.js"
-  },
-  "files": [
-    "dist"
+  "workspaces": [
+    "packages/*"
   ],
   "scripts": {
-    "build": "bash ./scripts/build.sh",
-    "build:ncc": "pnpm run clean && ncc build ./index.ts -o ./dist/ --minify --no-cache --no-source-map-register",
-    "clean": "rimraf --glob ./dist ./templates/**/__pycache__ ./templates/**/node_modules ./templates/**/poetry.lock",
-    "dev": "ncc build ./index.ts -w -o dist/",
-    "e2e": "playwright test",
-    "e2e:python": "playwright test e2e/shared e2e/python",
-    "e2e:typescript": "playwright test e2e/shared e2e/typescript",
+    "dev": "pnpm -r dev",
+    "build": "pnpm -r build",
+    "e2e": "pnpm -r e2e",
+    "lint": "eslint .",
     "format": "prettier --ignore-unknown --cache --check .",
     "format:write": "prettier --ignore-unknown --write .",
-    "lint": "eslint . --ignore-pattern dist --ignore-pattern e2e/cache",
-    "new-snapshot": "pnpm run build && changeset version --snapshot",
-    "new-version": "pnpm run build && changeset version",
-    "pack-install": "bash ./scripts/pack.sh",
     "prepare": "husky",
-    "release": "pnpm run build && changeset publish",
-    "release-snapshot": "pnpm run build && changeset publish --tag snapshot"
-  },
-  "dependencies": {
-    "@types/async-retry": "1.4.2",
-    "@types/ci-info": "2.0.0",
-    "@types/cross-spawn": "6.0.0",
-    "@types/fs-extra": "11.0.4",
-    "@types/node": "^20.11.7",
-    "@types/prompts": "2.0.1",
-    "@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"
+    "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"
   },
   "devDependencies": {
     "@changesets/cli": "^2.27.1",
-    "@playwright/test": "^1.41.1",
-    "@vercel/ncc": "0.38.1",
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^8.10.0",
+    "bunchee": "6.4.0",
     "husky": "^9.0.10",
-    "prettier": "^3.2.5",
-    "prettier-plugin-organize-imports": "^3.2.4",
-    "rimraf": "^5.0.5",
-    "typescript": "^5.3.3",
-    "wait-port": "^1.1.0"
+    "lint-staged": "^15.2.11",
+    "typescript-eslint": "^8.18.0",
+    "globals": "^15.12.0",
+    "eslint": "9.22.0",
+    "@eslint/js": "^9.25.0",
+    "eslint-config-next": "^15.1.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-react": "7.37.2",
+    "prettier": "^3.4.2",
+    "prettier-plugin-organize-imports": "^4.1.0",
+    "prettier-plugin-tailwindcss": "^0.6.11",
+    "typescript": "^5.7.3",
+    "@types/node": "^22.9.0",
+    "@types/react": "^19",
+    "@types/react-dom": "^19"
   },
   "packageManager": "pnpm@9.0.5",
   "engines": {

packages/create-llama/.gitignore

@@ -0,0 +1,65 @@
+# 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,5 +1,242 @@
 # create-llama
 
+## 0.5.16
+
+### Patch Changes
+
+- 6f75d4a: fix: unsupported language in code gen workflow
+- d0618fa: Fix LlamaCloud generate script issue
+
+## 0.5.15
+
+### Patch Changes
+
+- 527075c: Enable dev mode that allows updating code directly in the UI
+
+## 0.5.14
+
+### Patch Changes
+
+- 1df8cfb: Split artifacts use case to document generator and code generator
+- 1b5a519: chore: improve dev experience with nodemon
+- b3eb0ba: Fix typing check issue
+- 556f33c: fix chromadb dependency issue
+- 2451539: fix: remove dead generated ai code
+- 7a70390: Deprecate pro mode
+
+## 0.5.13
+
+### Patch Changes
+
+- f4ca602: Add artifact use case for Typescript template
+- f4ca602: Update typescript use cases to use the new workflow engine
+
+## 0.5.12
+
+### Patch Changes
+
+- 241d82a: Add artifacts use case (python)
+
+## 0.5.11
+
+### Patch Changes
+
+- 3960618: chore: create-llama monorepo
+- 8fe5fc2: chore: add llamaindex server package
+
+## 0.5.10
+
+### Patch Changes
+
+- 0a2e12a: Use uv as the default package manager
+
+## 0.5.9
+
+### Patch Changes
+
+- 4bc53ac: Bump new chat ui and update deep research component
+- 4bc53ac: Support generate UI for deep research use case (Typescript)
+
+## 0.5.8
+
+### Patch Changes
+
+- 765181a: chore: test typescript e2e with node 20 and 22
+
+## 0.5.7
+
+### Patch Changes
+
+- 5988657: chore: bump llmaindex
+
+## 0.5.6
+
+### Patch Changes
+
+- d363ced: Bump llamaindex server packages
+
+## 0.5.5
+
+### Patch Changes
+
+- ee85320: The default custom deep research component does not work.
+
+## 0.5.4
+
+### Patch Changes
+
+- 7c3b279: Support code generation of event components using an LLM (Python)
+
+## 0.5.3
+
+### Patch Changes
+
+- 76ec360: Update templates to use new chat ui config
+
+## 0.5.2
+
+### Patch Changes
+
+- c9f8f8d: Use custom component for deep research use case
+
+## 0.5.1
+
+### Patch Changes
+
+- 08b3e07: Simplify the local index code.
+
+## 0.5.0
+
+### Minor Changes
+
+- 54c9e2f: Simplified generated code using LlamaIndexServer
+
+### Patch Changes
+
+- 0e4ecfa: fix: add trycatch for generating error
+- ee69ce7: bump: chat-ui and tailwind v4
+
+## 0.4.0
+
+### Minor Changes
+
+- 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

packages/create-llama/create-app.ts

@@ -1,4 +1,3 @@
-/* eslint-disable import/no-extraneous-dependencies */
 import path from "path";
 import { green, yellow } from "picocolors";
 import { tryGitInit } from "./helpers/git";
@@ -7,17 +6,16 @@ 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 { 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" | "customApiPath"
+  "appName" | "root" | "isOnline" | "port"
 > & {
   appPath: string;
   frontend: boolean;
@@ -35,13 +33,12 @@ export async function createApp({
   communityProjectConfig,
   llamapack,
   vectorDb,
-  externalPort,
   postInstallAction,
   dataSources,
   tools,
   useLlamaParse,
   observability,
-  agents,
+  useCase,
 }: InstallAppArgs): Promise<void> {
   const root = path.resolve(appPath);
 
@@ -81,40 +78,30 @@ export async function createApp({
     communityProjectConfig,
     llamapack,
     vectorDb,
-    externalPort,
     postInstallAction,
     dataSources,
     tools,
     useLlamaParse,
     observability,
-    agents,
+    useCase,
   };
 
-  if (frontend) {
-    // install backend
-    const backendRoot = path.join(root, "backend");
-    await makeDir(backendRoot);
-    await installTemplate({ ...args, root: backendRoot, backend: true });
+  // Install backend
+  await installTemplate({ ...args, backend: true });
+
+  if (frontend && framework === "fastapi" && template !== "llamaindexserver") {
     // 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 writeDevcontainer(root, templatesDir, framework, frontend);
+  await configVSCode(root, templatesDir, framework);
 
   process.chdir(root);
   if (tryGitInit(root)) {
@@ -122,7 +109,7 @@ export async function createApp({
     console.log();
   }
 
-  if (toolsRequireConfig(tools)) {
+  if (toolsRequireConfig(tools) && template !== "llamaindexserver") {
     const configFile =
       framework === "fastapi" ? "config/tools.yaml" : "config/tools.json";
     console.log(

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

@@ -0,0 +1,285 @@
+import { expect, test } from "@playwright/test";
+import { exec } from "child_process";
+import fs from "fs";
+import path from "path";
+import util from "util";
+import { TemplateFramework, TemplateType, TemplateUseCase, TemplateVectorDB } from "../../helpers/types";
+import { RunCreateLlamaOptions, createTestDir, runCreateLlama } from "../utils";
+
+const execAsync = util.promisify(exec);
+
+const templateFramework: TemplateFramework = process.env.FRAMEWORK
+  ? (process.env.FRAMEWORK as TemplateFramework)
+  : "fastapi";
+const templateType: TemplateType = process.env.TEMPLATE_TYPE
+  ? (process.env.TEMPLATE_TYPE as TemplateType)
+  : "llamaindexserver";
+const useCases: TemplateUseCase[] = [
+  "agentic_rag",
+  "deep_research",
+  "financial_report",
+  "code_generator",
+  "document_generator",
+];
+const dataSource: string = process.env.DATASOURCE
+  ? process.env.DATASOURCE
+  : "--example-file";
+
+test.describe("Mypy check", () => {
+  test.describe.configure({ retries: 0 });
+
+    // Test for streaming template
+    test.describe("StreamingTemplate", () => {
+      test.skip(templateType !== "streaming", `skipping streaming test for ${templateType}`);
+      if (
+        dataSource === "--example-file" // XXX: this test provides its own data source - only trigger it on one data source (usually the CI matrix will trigger multiple data sources)
+      ) {
+        // vectorDBs, tools, and data source combinations to test
+        const vectorDbs: TemplateVectorDB[] = [
+          "mongo",
+          "pg",
+          "pinecone",
+          "milvus",
+          "astra",
+          "qdrant",
+          "chroma",
+          "weaviate",
+        ];
+        const toolOptions = [
+          "wikipedia.WikipediaToolSpec",
+          "google.GoogleSearchToolSpec",
+          "document_generator",
+          "artifact",
+        ];
+
+        const dataSources = [
+          "--example-file",
+          "--web-source https://www.example.com",
+          "--db-source mysql+pymysql://user:pass@localhost:3306/mydb",
+        ];
+
+        const observabilityOptions = ["llamatrace", "traceloop"];
+
+        // Test vector databases
+        for (const vectorDb of vectorDbs) {
+          test(`vectorDB: ${vectorDb} ${templateType}`, async () => {
+            const cwd = await createTestDir();
+            const { pyprojectPath } = await createAndCheckLlamaProject({
+              options: {
+                cwd,
+                templateType: "streaming",
+                templateFramework,
+                dataSource: "--example-file",
+                vectorDb,
+                tools: "none",
+                port: 3000,
+                postInstallAction: "none",
+                templateUI: undefined,
+                appType: "--no-frontend",
+                llamaCloudProjectName: undefined,
+                llamaCloudIndexName: undefined,
+                observability: undefined,
+              },
+            });
+
+            const pyprojectContent = fs.readFileSync(pyprojectPath, "utf-8");
+            if (vectorDb !== "none") {
+              if (vectorDb === "pg") {
+                expect(pyprojectContent).toContain(
+                  "llama-index-vector-stores-postgres",
+                );
+              } else {
+                expect(pyprojectContent).toContain(
+                  `llama-index-vector-stores-${vectorDb}`,
+                );
+              }
+            }
+          });
+        }
+
+        // // Test tools
+        for (const tool of toolOptions) {
+          test(`tool: ${tool} ${templateType}`, async () => {
+            const cwd = await createTestDir();
+            const { pyprojectPath } = await createAndCheckLlamaProject({
+              options: {
+                cwd,
+                templateType: "streaming",
+                templateFramework,
+                dataSource: "--example-file",
+                vectorDb: "none",
+                tools: tool,
+                port: 3000,
+                postInstallAction: "none",
+                templateUI: undefined,
+                appType: "--no-frontend",
+                llamaCloudProjectName: undefined,
+                llamaCloudIndexName: undefined,
+                observability: undefined,
+              },
+            });
+
+            const pyprojectContent = fs.readFileSync(pyprojectPath, "utf-8");
+            if (tool === "wikipedia.WikipediaToolSpec") {
+              expect(pyprojectContent).toContain("wikipedia");
+            }
+            if (tool === "google.GoogleSearchToolSpec") {
+              expect(pyprojectContent).toContain("google");
+            }
+          });
+        }
+
+        // // Test data sources
+        for (const dataSource of dataSources) {
+          test(`data source: ${dataSource} ${templateType}`, async () => {
+          const dataSourceType = dataSource.split(" ")[0];
+            const cwd = await createTestDir();
+            const { pyprojectPath } = await createAndCheckLlamaProject({
+              options: {
+                cwd,
+                templateType: "streaming",
+                templateFramework,
+                dataSource,
+                vectorDb: "none",
+                tools: "none",
+                port: 3000,
+                postInstallAction: "none",
+                templateUI: undefined,
+                appType: "--no-frontend",
+                llamaCloudProjectName: undefined,
+                llamaCloudIndexName: undefined,
+                observability: undefined,
+              },
+            });
+
+            const pyprojectContent = fs.readFileSync(pyprojectPath, "utf-8");
+            if (dataSource.includes("--web-source")) {
+              expect(pyprojectContent).toContain("llama-index-readers-web");
+            }
+            if (dataSource.includes("--db-source")) {
+              expect(pyprojectContent).toContain("llama-index-readers-database");
+            }
+          });
+        }
+
+        // Test observability options
+        for (const observability of observabilityOptions) {
+          test.describe(`observability: ${observability} ${templateType}`, async () => {
+            const cwd = await createTestDir();
+
+            const { pyprojectPath } = await createAndCheckLlamaProject({
+              options: {
+                cwd,
+                templateType: "streaming",
+                templateFramework,
+                dataSource: "--example-file",
+                vectorDb: "none",
+                tools: "none",
+                port: 3000,
+                postInstallAction: "none",
+                templateUI: undefined,
+                appType: "--no-frontend",
+                llamaCloudProjectName: undefined,
+                llamaCloudIndexName: undefined,
+                observability,
+              },
+            });
+          });
+        }
+      }
+    });
+
+    test.describe("LlamaIndexServer", async () => {
+      test.skip(templateType !== "llamaindexserver", `skipping llamaindexserver test for ${templateType}`);
+      test.skip(dataSource !== "--example-file", `skipping llamaindexserver test for ${dataSource}`);
+      for (const useCase of useCases) {
+        const cwd = await createTestDir();
+        await createAndCheckLlamaProject({
+          options: {
+            cwd,
+            templateType: "llamaindexserver",
+            templateFramework,
+            dataSource,
+            vectorDb: "none",
+            tools: "none",
+            port: 3000,
+            postInstallAction: "none",
+            templateUI: undefined,
+            appType: "--no-frontend",
+            llamaCloudProjectName: undefined,
+            llamaCloudIndexName: undefined,
+            observability: undefined,
+            useCase,
+          },
+        });
+      }
+    });
+
+    async function createAndCheckLlamaProject({
+      options,
+    }: {
+      options: RunCreateLlamaOptions;
+    }): Promise<{ pyprojectPath: string; projectPath: string }> {
+      const result = await runCreateLlama(options);
+      const name = result.projectName;
+      const projectPath = path.join(options.cwd, name);
+
+      // Check if the app folder exists
+      expect(fs.existsSync(projectPath)).toBeTruthy();
+
+      // Check if pyproject.toml exists
+      const pyprojectPath = path.join(projectPath, "pyproject.toml");
+      expect(fs.existsSync(pyprojectPath)).toBeTruthy();
+
+      // Modify environment for the command
+      const commandEnv = {
+        ...process.env,
+      };
+
+      console.log("Running uv venv...");
+      try {
+        const { stdout: venvStdout, stderr: venvStderr } = await execAsync(
+          "uv venv",
+          { cwd: projectPath, env: commandEnv },
+        );
+        console.log("uv venv stdout:", venvStdout);
+        console.error("uv venv stderr:", venvStderr);
+      } catch (error) {
+        console.error("Error running uv venv:", error);
+        throw error; // Re-throw error to fail the test
+      }
+
+      console.log("Running uv sync...");
+      try {
+        const { stdout: syncStdout, stderr: syncStderr } = await execAsync(
+          "uv sync --all-extras",
+          { cwd: projectPath, env: commandEnv },
+        );
+        console.log("uv sync stdout:", syncStdout);
+        console.error("uv sync stderr:", syncStderr);
+      } catch (error) {
+        console.error("Error running uv sync:", error);
+        throw error; // Re-throw error to fail the test
+      }
+
+      console.log("Running uv run mypy ....");
+      try {
+        const { stdout: mypyStdout, stderr: mypyStderr } = await execAsync(
+          "uv run mypy .",
+          { cwd: projectPath, env: commandEnv },
+        );
+        console.log("uv run mypy stdout:", mypyStdout);
+        console.error("uv run mypy stderr:", mypyStderr);
+        // Assuming mypy success means no output or specific success message
+        // Adjust checks based on actual expected mypy output
+      } catch (error) {
+        console.error("Error running mypy:", error);
+        throw error;
+      }
+
+      // If we reach this point without throwing an error, the test passes
+      expect(true).toBeTruthy();
+
+    return { pyprojectPath, projectPath };
+  }
+});

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

@@ -1,4 +1,3 @@
-/* eslint-disable turbo/no-undeclared-env-vars */
 import { expect, test } from "@playwright/test";
 import { ChildProcess } from "child_process";
 import fs from "fs";
@@ -13,21 +12,31 @@ 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 dataSource: string = process.env.DATASOURCE
+  ? (process.env.DATASOURCE as string)
+  : "--example-file";
+const llamaCloudProjectName = "create-llama";
+const llamaCloudIndexName = "e2e-test";
+
 const templateUI: TemplateUI = "shadcn";
 const templatePostInstallAction: TemplatePostInstallAction = "runApp";
-const appType: AppType = templateFramework === "nextjs" ? "" : "--frontend";
+const appType: AppType = "--frontend";
 const userMessage = "Write a blog post about physical standards for letters";
-const templateAgents = ["financial_report", "blog", "form_filling"];
+const templateUseCases = [
+  "agentic_rag",
+  "financial_report",
+  "deep_research",
+  "code_generator",
+];
 
-for (const agents of templateAgents) {
-  test.describe(`Test multiagent template ${agents} ${templateFramework} ${dataSource} ${templateUI} ${appType} ${templatePostInstallAction}`, async () => {
+for (const useCase of templateUseCases) {
+  test.describe(`Test use case ${useCase} ${templateFramework} ${dataSource} ${templateUI} ${appType} ${templatePostInstallAction}`, async () => {
     test.skip(
-      process.platform !== "linux" || process.env.DATASOURCE === "--no-files",
-      "The multiagent template currently only works with files. We also only run on Linux to speed up tests.",
+      dataSource === "--no-files" || templateFramework === "express",
+      "The llamaindexserver template currently only works with nextjs, fastapi. We also only run on Linux to speed up tests.",
     );
+    const useLlamaParse = dataSource === "--llamacloud";
     let port: number;
-    let externalPort: number;
     let cwd: string;
     let name: string;
     let appProcess: ChildProcess;
@@ -36,20 +45,21 @@ for (const agents of templateAgents) {
 
     test.beforeAll(async () => {
       port = Math.floor(Math.random() * 10000) + 10000;
-      externalPort = port + 1;
       cwd = await createTestDir();
       const result = await runCreateLlama({
         cwd,
-        templateType: "multiagent",
+        templateType: "llamaindexserver",
         templateFramework,
         dataSource,
         vectorDb,
         port,
-        externalPort,
         postInstallAction: templatePostInstallAction,
         templateUI,
         appType,
-        agents,
+        useCase,
+        llamaCloudProjectName,
+        llamaCloudIndexName,
+        useLlamaParse,
       });
       name = result.projectName;
       appProcess = result.appProcess;
@@ -61,16 +71,25 @@ for (const agents of templateAgents) {
     });
 
     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();
+      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(
-        agents === "financial_report" || agents === "form_filling",
-        "Skip chat tests for financial report and form filling.",
+        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);
@@ -82,6 +101,12 @@ for (const agents of templateAgents) {
       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();
     });
 

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

@@ -0,0 +1,63 @@
+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,4 +1,3 @@
-/* eslint-disable turbo/no-undeclared-env-vars */
 import { expect, test } from "@playwright/test";
 import { ChildProcess } from "child_process";
 import fs from "fs";
@@ -22,7 +21,7 @@ const templatePostInstallAction: TemplatePostInstallAction = "runApp";
 const llamaCloudProjectName = "create-llama";
 const llamaCloudIndexName = "e2e-test";
 
-const appType: AppType = templateFramework === "nextjs" ? "" : "--frontend";
+const appType: AppType = templateFramework === "fastapi" ? "--frontend" : "";
 const userMessage =
   dataSource !== "--no-files" ? "Physical standard for letters" : "Hello";
 
@@ -35,7 +34,6 @@ test.describe(`Test streaming template ${templateFramework} ${dataSource} ${temp
   }
 
   let port: number;
-  let externalPort: number;
   let cwd: string;
   let name: string;
   let appProcess: ChildProcess;
@@ -44,7 +42,6 @@ test.describe(`Test streaming template ${templateFramework} ${dataSource} ${temp
 
   test.beforeAll(async () => {
     port = Math.floor(Math.random() * 10000) + 10000;
-    externalPort = port + 1;
     cwd = await createTestDir();
     const result = await runCreateLlama({
       cwd,
@@ -53,7 +50,6 @@ test.describe(`Test streaming template ${templateFramework} ${dataSource} ${temp
       dataSource,
       vectorDb,
       port,
-      externalPort,
       postInstallAction: templatePostInstallAction,
       templateUI,
       appType,
@@ -68,8 +64,11 @@ test.describe(`Test streaming template ${templateFramework} ${dataSource} ${temp
     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(
+      templatePostInstallAction !== "runApp" || templateFramework === "express",
+    );
     await page.goto(`http://localhost:${port}`);
     await expect(page.getByText("Built by LlamaIndex")).toBeVisible();
   });
@@ -77,7 +76,9 @@ test.describe(`Test streaming template ${templateFramework} ${dataSource} ${temp
   test("Frontend should be able to submit a message and receive a response", async ({
     page,
   }) => {
-    test.skip(templatePostInstallAction !== "runApp");
+    test.skip(
+      templatePostInstallAction !== "runApp" || templateFramework === "express",
+    );
     await page.goto(`http://localhost:${port}`);
     await page.fill("form textarea", userMessage);
     const [response] = await Promise.all([
@@ -102,7 +103,7 @@ test.describe(`Test streaming template ${templateFramework} ${dataSource} ${temp
     test.skip(templatePostInstallAction !== "runApp");
     test.skip(templateFramework === "nextjs");
     const response = await request.post(
-      `http://localhost:${externalPort}/api/chat/request`,
+      `http://localhost:${port}/api/chat/request`,
       {
         data: {
           messages: [

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

@@ -0,0 +1,161 @@
+import { expect, test } from "@playwright/test";
+import { exec } from "child_process";
+import fs from "fs";
+import path from "path";
+import util from "util";
+import {
+  TemplateFramework,
+  TemplateType,
+  TemplateUseCase,
+  TemplateVectorDB,
+} from "../../helpers/types";
+import { createTestDir, runCreateLlama } from "../utils";
+
+const execAsync = util.promisify(exec);
+
+const templateFramework: TemplateFramework = process.env.FRAMEWORK
+  ? (process.env.FRAMEWORK as TemplateFramework)
+  : "nextjs";
+const templateType: TemplateType = process.env.TEMPLATE_TYPE
+  ? (process.env.TEMPLATE_TYPE as TemplateType)
+  : "llamaindexserver";
+const useCases: TemplateUseCase[] = [
+  "agentic_rag",
+  "deep_research",
+  "financial_report",
+  "code_generator",
+  "document_generator",
+];
+const dataSource: string = process.env.DATASOURCE
+  ? process.env.DATASOURCE
+  : "--example-file";
+
+// vectorDBs combinations to test
+const vectorDbs: TemplateVectorDB[] = [
+  "mongo",
+  "pg",
+  "qdrant",
+  "pinecone",
+  "milvus",
+  "astra",
+  "chroma",
+  "llamacloud",
+  "weaviate",
+];
+
+test.describe("Test resolve TS dependencies", () => {
+  test.describe.configure({ retries: 0 });
+
+  // Test vector DBs without LlamaParse
+  for (const vectorDb of vectorDbs) {
+    const optionDescription = `templateType: ${templateType}, vectorDb: ${vectorDb}, dataSource: ${dataSource}`;
+
+    test(`Vector DB test - ${optionDescription}`, async () => {
+      // skip vectordb test for llamaindexserver
+      test.skip(
+        templateType === "llamaindexserver",
+        "skipping vectorDB test for llamaindexserver",
+      );
+
+      await runTest({
+        templateType: templateType,
+        useLlamaParse: false, // Disable LlamaParse for vectorDB test
+        vectorDb: vectorDb,
+      });
+    });
+  }
+
+  // No vectorDB, with LlamaParse and useCase
+  // Only need to test use case with example data source
+  if (dataSource === "--example-file") {
+    for (const useCase of useCases) {
+      const optionDescription = `templateType: ${templateType}, useCase: ${useCase}`;
+      test.describe(`useCase test - ${optionDescription}`, () => {
+        test.skip(
+          templateType === "streaming",
+          "Skipping use case test for streaming template.",
+        );
+        test(`no llamaParse - ${optionDescription}`, async () => {
+          await runTest({
+            templateType: templateType,
+            useLlamaParse: false,
+            useCase: useCase,
+          });
+        });
+        // Skipping llamacloud for the use case doesn't use index.
+        if (useCase !== "code_generator" && useCase !== "document_generator") {
+          test(`llamaParse - ${optionDescription}`, async () => {
+            await runTest({
+              templateType: templateType,
+              useLlamaParse: true,
+              useCase: useCase,
+            });
+          });
+        }
+      });
+    }
+  }
+});
+
+async function runTest(options: {
+  templateType: TemplateType;
+  useLlamaParse: boolean;
+  useCase?: TemplateUseCase;
+  vectorDb?: TemplateVectorDB;
+}) {
+  const cwd = await createTestDir();
+
+  const result = await runCreateLlama({
+    cwd: cwd,
+    templateType: options.templateType,
+    templateFramework: templateFramework,
+    dataSource: dataSource,
+    vectorDb: options.vectorDb ?? "none",
+    port: 3000,
+    postInstallAction: "none",
+    templateUI: undefined,
+    appType: templateFramework === "nextjs" ? "" : "--no-frontend",
+    llamaCloudProjectName: undefined,
+    llamaCloudIndexName: undefined,
+    tools: undefined,
+    useLlamaParse: options.useLlamaParse,
+    useCase: options.useCase,
+  });
+  const name = result.projectName;
+
+  // Check if the app folder exists
+  const appDir = path.join(cwd, name);
+  const dirExists = fs.existsSync(appDir);
+  expect(dirExists).toBeTruthy();
+
+  // Install dependencies using pnpm
+  try {
+    const { stderr: installStderr } = await execAsync(
+      "pnpm install --prefer-offline --ignore-workspace",
+      {
+        cwd: appDir,
+      },
+    );
+  } catch (error) {
+    console.error("Error installing dependencies:", error);
+    throw error;
+  }
+
+  // Run tsc type check and capture the output
+  try {
+    const { stdout, stderr } = await execAsync(
+      "pnpm exec tsc -b --diagnostics",
+      {
+        cwd: appDir,
+      },
+    );
+    // Check if there's any error output
+    expect(stderr).toBeFalsy();
+
+    // Log the stdout for debugging purposes
+    console.log("TypeScript type-check output:", stdout);
+  } catch (error) {
+    console.error("Error running tsc:", error);
+    throw error;
+  }
+}

packages/create-llama/e2e/utils.ts

@@ -25,7 +25,6 @@ export type RunCreateLlamaOptions = {
   dataSource: string;
   vectorDb: TemplateVectorDB;
   port: number;
-  externalPort: number;
   postInstallAction: TemplatePostInstallAction;
   templateUI?: TemplateUI;
   appType?: AppType;
@@ -34,7 +33,7 @@ export type RunCreateLlamaOptions = {
   tools?: string;
   useLlamaParse?: boolean;
   observability?: string;
-  agents?: string;
+  useCase?: string;
 };
 
 export async function runCreateLlama({
@@ -44,7 +43,6 @@ export async function runCreateLlama({
   dataSource,
   vectorDb,
   port,
-  externalPort,
   postInstallAction,
   templateUI,
   appType,
@@ -53,7 +51,7 @@ export async function runCreateLlama({
   tools,
   useLlamaParse,
   observability,
-  agents,
+  useCase,
 }: RunCreateLlamaOptions): Promise<CreateLlamaResult> {
   if (!process.env.OPENAI_API_KEY || !process.env.LLAMA_CLOUD_API_KEY) {
     throw new Error(
@@ -69,8 +67,8 @@ export async function runCreateLlama({
   ].join("-");
 
   // Handle different data source types
-  let dataSourceArgs = [];
-  if (dataSource.includes("--web-source" || "--db-source")) {
+  const dataSourceArgs = [];
+  if (dataSource.includes("--web-source")) {
     const webSource = dataSource.split(" ")[1];
     dataSourceArgs.push("--web-source", webSource);
   } else if (dataSource.includes("--db-source")) {
@@ -90,21 +88,15 @@ export async function runCreateLlama({
     ...dataSourceArgs,
     "--vector-db",
     vectorDb,
-    "--open-ai-key",
-    process.env.OPENAI_API_KEY,
-    "--use-pnpm",
+    "--use-npm",
     "--port",
     port,
-    "--external-port",
-    externalPort,
     "--post-install-action",
     postInstallAction,
     "--tools",
     tools ?? "none",
     "--observability",
     "none",
-    "--llama-cloud-key",
-    process.env.LLAMA_CLOUD_API_KEY,
   ];
 
   if (templateUI) {
@@ -121,8 +113,13 @@ export async function runCreateLlama({
   if (observability) {
     commandArgs.push("--observability", observability);
   }
-  if (templateType === "multiagent" && agents) {
-    commandArgs.push("--agents", agents);
+  if (
+    (templateType === "multiagent" ||
+      templateType === "reflex" ||
+      templateType === "llamaindexserver") &&
+    useCase
+  ) {
+    commandArgs.push("--use-case", useCase);
   }
 
   const command = commandArgs.join(" ");
@@ -146,12 +143,7 @@ export async function runCreateLlama({
 
   // Wait for app to start
   if (postInstallAction === "runApp") {
-    await checkAppHasStarted(
-      appType === "--frontend",
-      templateFramework,
-      port,
-      externalPort,
-    );
+    await waitPorts([port]);
   } else if (postInstallAction === "dependencies") {
     await waitForProcess(appProcess, 1000 * 60); // wait 1 min for dependencies to be resolved
   } else {
@@ -171,19 +163,6 @@ export async function createTestDir() {
   return cwd;
 }
 
-// eslint-disable-next-line max-params
-async function checkAppHasStarted(
-  frontend: boolean,
-  framework: TemplateFramework,
-  port: number,
-  externalPort: number,
-) {
-  const portsToWait = frontend
-    ? [port, externalPort]
-    : [framework === "nextjs" ? port : externalPort];
-  await waitPorts(portsToWait);
-}
-
 async function waitPorts(ports: number[]): Promise<void> {
   const waitForPort = async (port: number): Promise<void> => {
     await waitPort({

packages/create-llama/helpers/copy.ts

@@ -1,4 +1,3 @@
-/* eslint-disable import/no-extraneous-dependencies */
 import { async as glob } from "fast-glob";
 import fs from "fs";
 import path from "path";
@@ -61,6 +60,9 @@ export const assetRelocator = (name: string) => {
     case "README-template.md": {
       return "README.md";
     }
+    case "vscode_settings.json": {
+      return "settings.json";
+    }
     default: {
       return name;
     }

packages/create-llama/helpers/datasources.ts

@@ -18,6 +18,7 @@ export const EXAMPLE_10K_SEC_FILES: TemplateDataSource[] = [
       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",
     },
   },
   {
@@ -26,10 +27,31 @@ export const EXAMPLE_10K_SEC_FILES: TemplateDataSource[] = [
       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,

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

@@ -13,6 +13,12 @@ import {
 
 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;
@@ -38,6 +44,7 @@ const renderEnvVar = (envVars: EnvVar[]): string => {
 const getVectorDBEnvs = (
   vectorDb?: TemplateVectorDB,
   framework?: TemplateFramework,
+  template?: TemplateType,
 ): EnvVar[] => {
   if (!vectorDb || !framework) {
     return [];
@@ -162,7 +169,7 @@ const getVectorDBEnvs = (
           description:
             "The organization ID for the LlamaCloud project (uses default organization if not specified)",
         },
-        ...(framework === "nextjs"
+        ...(framework === "nextjs" && template !== "llamaindexserver"
           ? // activate index selector per default (not needed for non-NextJS backends as it's handled by createFrontendEnvFile)
             [
               {
@@ -174,7 +181,7 @@ const getVectorDBEnvs = (
             ]
           : []),
       ];
-    case "chroma":
+    case "chroma": {
       const envs = [
         {
           name: "CHROMA_COLLECTION",
@@ -199,6 +206,7 @@ Otherwise, use CHROMA_HOST and CHROMA_PORT config above`,
         });
       }
       return envs;
+    }
     case "weaviate":
       return [
         {
@@ -217,7 +225,15 @@ Otherwise, use CHROMA_HOST and CHROMA_PORT config above`,
         },
       ];
     default:
-      return [];
+      return template !== "llamaindexserver"
+        ? [
+            {
+              name: "STORAGE_CACHE_DIR",
+              description: "The directory to store the local storage cache.",
+              value: ".cache",
+            },
+          ]
+        : [];
   }
 };
 
@@ -370,37 +386,48 @@ const getModelEnvs = (modelConfig: ModelConfig): EnvVar[] => {
 
 const getFrameworkEnvs = (
   framework: TemplateFramework,
+  template: TemplateType,
   port?: number,
 ): EnvVar[] => {
   const sPort = port?.toString() || "8000";
-  const result: EnvVar[] = [
-    {
-      name: "FILESERVER_URL_PREFIX",
-      description:
-        "FILESERVER_URL_PREFIX is the URL prefix of the server storing the images generated by the interpreter.",
-      value:
-        framework === "nextjs"
-          ? // FIXME: if we are using nextjs, port should be 3000
-            "http://localhost:3000/api/files"
-          : `http://localhost:${sPort}/api/files`,
-    },
-  ];
+  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 backend app.",
+          description: "The address to start the FastAPI app.",
           value: "0.0.0.0",
         },
         {
           name: "APP_PORT",
-          description: "The port to start the backend app.",
+          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;
 };
 
@@ -436,9 +463,6 @@ const getSystemPromptEnv = (
   dataSources?: TemplateDataSource[],
   template?: TemplateType,
 ): EnvVar[] => {
-  const defaultSystemPrompt =
-    "You are a helpful assistant who helps users with their questions.";
-
   const systemPromptEnv: EnvVar[] = [];
   // build tool system prompt by merging all tool system prompts
   // multiagent template doesn't need system prompt
@@ -453,9 +477,12 @@ const getSystemPromptEnv = (
       }
     });
 
-    const systemPrompt = toolSystemPrompt
-      ? `\"${toolSystemPrompt}\"`
-      : defaultSystemPrompt;
+    const systemPrompt =
+      '"' +
+      DEFAULT_SYSTEM_PROMPT +
+      (dataSources?.length ? `\n${DATA_SOURCES_PROMPT}` : "") +
+      (toolSystemPrompt ? `\n${toolSystemPrompt}` : "") +
+      '"';
 
     systemPromptEnv.push({
       name: "SYSTEM_PROMPT",
@@ -506,7 +533,7 @@ Here is the conversation history
 ---------------------
 {conversation}
 ---------------------
-Given the conversation history, please give me 3 questions that you might ask next!
+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>
@@ -547,28 +574,44 @@ export const createBackendEnvFile = async (
     | "framework"
     | "dataSources"
     | "template"
-    | "externalPort"
+    | "port"
     | "tools"
     | "observability"
+    | "useLlamaParse"
   >,
 ) => {
   // Init env values
   const envFileName = ".env";
   const envVars: EnvVar[] = [
-    {
-      name: "LLAMA_CLOUD_API_KEY",
-      description: `The Llama Cloud API key.`,
-      value: opts.llamaCloudKey,
-    },
-    // Add environment variables of each component
-    ...getModelEnvs(opts.modelConfig),
-    ...getEngineEnvs(),
-    ...getVectorDBEnvs(opts.vectorDb, opts.framework),
-    ...getFrameworkEnvs(opts.framework, opts.externalPort),
+    ...(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),
-    ...getTemplateEnvs(opts.template),
-    ...getObservabilityEnvs(opts.observability),
-    ...getSystemPromptEnv(opts.tools, opts.dataSources, opts.template),
+    ...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);
@@ -579,18 +622,10 @@ export const createBackendEnvFile = async (
 export const createFrontendEnvFile = async (
   root: string,
   opts: {
-    customApiPath?: string;
     vectorDb?: TemplateVectorDB;
   },
 ) => {
   const defaultFrontendEnvs = [
-    {
-      name: "NEXT_PUBLIC_CHAT_API",
-      description: "The backend API for chat endpoint.",
-      value: opts.customApiPath
-        ? opts.customApiPath
-        : "http://localhost:8000/api/chat",
-    },
     {
       name: "NEXT_PUBLIC_USE_LLAMACLOUD",
       description: "Let's the user change indexes in LlamaCloud projects",

packages/create-llama/helpers/git.ts

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

packages/create-llama/helpers/index.ts

@@ -1,7 +1,7 @@
 import { callPackageManager } from "./install";
 
 import path from "path";
-import { cyan } from "picocolors";
+import picocolors, { cyan } from "picocolors";
 
 import fsExtra from "fs-extra";
 import { writeLoadersConfig } from "./datasources";
@@ -9,7 +9,6 @@ import { createBackendEnvFile, createFrontendEnvFile } from "./env-variables";
 import { PackageManager } from "./get-pkg-manager";
 import { installLlamapackProject } from "./llama-pack";
 import { makeDir } from "./make-dir";
-import { isHavingPoetryLockFile, tryPoetryRun } from "./poetry";
 import { installPythonTemplate } from "./python";
 import { downloadAndExtractRepo } from "./repo";
 import { ConfigFileType, writeToolsConfig } from "./tools";
@@ -19,9 +18,11 @@ import {
   ModelConfig,
   TemplateDataSource,
   TemplateFramework,
+  TemplateUseCase,
   TemplateVectorDB,
 } from "./types";
 import { installTSTemplate } from "./typescript";
+import { isHavingUvLockFile, tryUvRun } from "./uv";
 
 const checkForGenerateScript = (
   modelConfig: ModelConfig,
@@ -41,7 +42,11 @@ const checkForGenerateScript = (
     missingSettings.push("your LLAMA_CLOUD_API_KEY");
   }
 
-  if (vectorDb !== "none" && vectorDb !== "llamacloud") {
+  if (
+    vectorDb !== undefined &&
+    vectorDb !== "none" &&
+    vectorDb !== "llamacloud"
+  ) {
     missingSettings.push("your Vector DB environment variables");
   }
 
@@ -56,11 +61,12 @@ async function generateContextData(
   vectorDb?: TemplateVectorDB,
   llamaCloudKey?: string,
   useLlamaParse?: boolean,
+  useCase?: TemplateUseCase,
 ) {
   if (packageManager) {
     const runGenerate = `${cyan(
       framework === "fastapi"
-        ? "poetry run generate"
+        ? "uv run generate"
         : `${packageManager} run generate`,
     )}`;
 
@@ -74,32 +80,43 @@ async function generateContextData(
     if (!missingSettings.length) {
       // If all the required environment variables are set, run the generate script
       if (framework === "fastapi") {
-        if (isHavingPoetryLockFile()) {
+        if (isHavingUvLockFile()) {
           console.log(`Running ${runGenerate} to generate the context data.`);
-          const result = tryPoetryRun("poetry run generate");
+          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"]);
+        const shouldRunGenerate =
+          useCase !== "code_generator" && useCase !== "document_generator"; // Artifact use case doesn't use index.
+
+        if (shouldRunGenerate) {
+          await callPackageManager(packageManager, true, ["run", "generate"]);
+        }
         return;
       }
     }
 
     const settingsMessage = `After setting ${missingSettings.join(" and ")}, run ${runGenerate} to generate the context data.`;
-    console.log(`\n${settingsMessage}\n\n`);
+    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, Buffer.from(fileBuffer));
+  await fsExtra.writeFile(destPath, new Uint8Array(fileBuffer));
 };
 
 const prepareContextData = async (
@@ -118,7 +135,8 @@ const prepareContextData = async (
       const destPath = path.join(
         root,
         "data",
-        path.basename(dataSourceConfig.url.toString()),
+        dataSourceConfig.filename ??
+          path.basename(dataSourceConfig.url.toString()),
       );
       await downloadFile(dataSourceConfig.url.toString(), destPath);
     } else {
@@ -165,6 +183,17 @@ export const installTemplate = async (
 
   if (props.framework === "fastapi") {
     await installPythonTemplate(props);
+  } else {
+    await installTSTemplate(props);
+  }
+
+  // write configurations
+  if (props.template !== "llamaindexserver") {
+    await writeToolsConfig(
+      props.root,
+      props.tools,
+      props.framework === "fastapi" ? ConfigFileType.YAML : ConfigFileType.JSON,
+    );
     if (props.vectorDb !== "llamacloud") {
       // write loaders configuration (currently Python only)
       // not needed for LlamaCloud as it has its own loaders
@@ -174,26 +203,13 @@ export const installTemplate = async (
         props.useLlamaParse,
       );
     }
-  } else {
-    await installTSTemplate(props);
   }
 
-  // write tools configuration
-  await writeToolsConfig(
-    props.root,
-    props.tools,
-    props.framework === "fastapi" ? ConfigFileType.YAML : ConfigFileType.JSON,
-  );
-
   if (props.backend) {
     // This is a backend, so we need to copy the test data and create the env file.
 
     // Copy the environment file to the target directory.
-    if (
-      props.template === "streaming" ||
-      props.template === "multiagent" ||
-      props.template === "extractor"
-    ) {
+    if (props.template !== "community" && props.template !== "llamapack") {
       await createBackendEnvFile(props.root, props);
     }
 
@@ -215,6 +231,7 @@ export const installTemplate = async (
         props.vectorDb,
         props.llamaCloudKey,
         props.useLlamaParse,
+        props.useCase,
       );
     }
 
@@ -225,7 +242,6 @@ export const installTemplate = async (
   } else {
     // this is a frontend for a full-stack app, create .env file with model information
     await createFrontendEnvFile(props.root, {
-      customApiPath: props.customApiPath,
       vectorDb: props.vectorDb,
     });
   }

packages/create-llama/helpers/install.ts

@@ -1,4 +1,3 @@
-/* eslint-disable import/no-extraneous-dependencies */
 import spawn from "cross-spawn";
 import { yellow } from "picocolors";
 import type { PackageManager } from "./get-pkg-manager";

packages/create-llama/helpers/is-folder-empty.ts

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

packages/create-llama/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({ noRoot: true });
+    installPythonDependencies();
   }
 };

packages/create-llama/helpers/poetry.ts

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

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

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

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

@@ -3,6 +3,7 @@ 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";
@@ -30,7 +31,7 @@ export async function askOpenAIQuestions({
     },
   };
 
-  if (!config.apiKey) {
+  if (!config.apiKey && !isCI) {
     const { key } = await prompts(
       {
         type: "text",

packages/create-llama/helpers/python.ts

@@ -3,15 +3,16 @@ 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 { isPoetryAvailable, tryPoetryInstall } from "./poetry";
 import { Tool } from "./tools";
 import {
   InstallTemplateArgs,
   ModelConfig,
   TemplateDataSource,
+  TemplateObservability,
   TemplateType,
   TemplateVectorDB,
 } from "./types";
@@ -20,6 +21,7 @@ interface Dependency {
   name: string;
   version?: string;
   extras?: string[];
+  constraints?: Record<string, string>;
 }
 
 const getAdditionalDependencies = (
@@ -28,6 +30,8 @@ const getAdditionalDependencies = (
   dataSources?: TemplateDataSource[],
   tools?: Tool[],
   templateType?: TemplateType,
+  observability?: TemplateObservability,
+  // eslint-disable-next-line max-params
 ) => {
   const dependencies: Dependency[] = [];
 
@@ -36,67 +40,77 @@ const getAdditionalDependencies = (
     case "mongo": {
       dependencies.push({
         name: "llama-index-vector-stores-mongodb",
-        version: "^0.3.1",
+        version: ">=0.3.2,<0.4.0",
       });
       break;
     }
     case "pg": {
       dependencies.push({
         name: "llama-index-vector-stores-postgres",
-        version: "^0.2.5",
+        version: ">=0.3.2,<0.4.0",
       });
       break;
     }
     case "pinecone": {
       dependencies.push({
         name: "llama-index-vector-stores-pinecone",
-        version: "^0.2.1",
+        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.2.0",
+        version: ">=0.3.0,<0.4.0",
       });
       dependencies.push({
         name: "pymilvus",
-        version: "2.4.4",
+        version: ">=2.4.4,<3.0.0",
       });
       break;
     }
     case "astra": {
       dependencies.push({
         name: "llama-index-vector-stores-astra-db",
-        version: "^0.2.0",
+        version: ">=0.4.0,<0.5.0",
       });
       break;
     }
     case "qdrant": {
       dependencies.push({
         name: "llama-index-vector-stores-qdrant",
-        version: "^0.3.0",
+        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.2.0",
+        version: ">=0.4.0,<0.5.0",
+      });
+      dependencies.push({
+        name: "onnxruntime",
+        version: "<1.22.0",
       });
       break;
     }
     case "weaviate": {
       dependencies.push({
         name: "llama-index-vector-stores-weaviate",
-        version: "^1.1.1",
+        version: ">=1.2.3,<2.0.0",
       });
       break;
     }
     case "llamacloud":
       dependencies.push({
         name: "llama-index-indices-managed-llama-cloud",
-        version: "^0.3.1",
+        version: ">=0.6.3,<0.7.0",
       });
       break;
   }
@@ -109,28 +123,28 @@ const getAdditionalDependencies = (
         case "file":
           dependencies.push({
             name: "docx2txt",
-            version: "^0.8",
+            version: ">=0.8,<0.9",
           });
           break;
         case "web":
           dependencies.push({
             name: "llama-index-readers-web",
-            version: "^0.2.2",
+            version: ">=0.3.0,<0.4.0",
           });
           break;
         case "db":
           dependencies.push({
             name: "llama-index-readers-database",
-            version: "^0.2.0",
+            version: ">=0.3.0,<0.4.0",
           });
           dependencies.push({
             name: "pymysql",
-            version: "^1.1.0",
+            version: ">=1.1.0,<2.0.0",
             extras: ["rsa"],
           });
           dependencies.push({
             name: "psycopg2-binary",
-            version: "^2.9.9",
+            version: ">=2.9.9,<3.0.0",
           });
           break;
       }
@@ -149,150 +163,122 @@ const getAdditionalDependencies = (
     case "ollama":
       dependencies.push({
         name: "llama-index-llms-ollama",
-        version: "0.3.0",
+        version: ">=0.5.0,<0.6.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-ollama",
-        version: "0.3.0",
+        version: ">=0.6.0,<0.7.0",
       });
       break;
     case "openai":
       if (templateType !== "multiagent") {
         dependencies.push({
           name: "llama-index-llms-openai",
-          version: "^0.2.0",
+          version: ">=0.3.2,<0.4.0",
         });
         dependencies.push({
           name: "llama-index-embeddings-openai",
-          version: "^0.2.3",
+          version: ">=0.3.1,<0.4.0",
         });
         dependencies.push({
           name: "llama-index-agent-openai",
-          version: "^0.3.0",
+          version: ">=0.4.0,<0.5.0",
         });
       }
       break;
     case "groq":
-      // Fastembed==0.2.0 does not support python3.13 at the moment
-      // Fixed the python version less than 3.13
-      dependencies.push({
-        name: "python",
-        version: "^3.11,<3.13",
-      });
       dependencies.push({
         name: "llama-index-llms-groq",
-        version: "0.2.0",
+        version: ">=0.3.0,<0.4.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-fastembed",
-        version: "^0.2.0",
+        version: ">=0.3.0,<0.4.0",
       });
       break;
     case "anthropic":
-      // Fastembed==0.2.0 does not support python3.13 at the moment
-      // Fixed the python version less than 3.13
-      dependencies.push({
-        name: "python",
-        version: "^3.11,<3.13",
-      });
       dependencies.push({
         name: "llama-index-llms-anthropic",
-        version: "0.3.0",
+        version: ">=0.6.0,<0.7.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-fastembed",
-        version: "^0.2.0",
+        version: ">=0.3.0,<0.4.0",
       });
       break;
     case "gemini":
       dependencies.push({
         name: "llama-index-llms-gemini",
-        version: "0.3.4",
+        version: ">=0.4.0,<0.5.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-gemini",
-        version: "^0.2.0",
+        version: ">=0.3.0,<0.4.0",
       });
       break;
     case "mistral":
       dependencies.push({
         name: "llama-index-llms-mistralai",
-        version: "0.2.1",
+        version: ">=0.4.0,<0.5.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-mistralai",
-        version: "0.2.0",
+        version: ">=0.3.0,<0.4.0",
       });
       break;
     case "azure-openai":
       dependencies.push({
         name: "llama-index-llms-azure-openai",
-        version: "0.2.0",
+        version: ">=0.3.0,<0.4.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-azure-openai",
-        version: "0.2.4",
+        version: ">=0.3.0,<0.4.0",
       });
       break;
     case "huggingface":
       dependencies.push({
         name: "llama-index-llms-huggingface",
-        version: "^0.3.5",
+        version: ">=0.5.0,<0.6.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-huggingface",
-        version: "^0.3.1",
+        version: ">=0.5.0,<0.6.0",
       });
       dependencies.push({
         name: "optimum",
-        version: "^1.23.3",
+        version: ">=1.23.3,<2.0.0",
         extras: ["onnxruntime"],
       });
       break;
     case "t-systems":
       dependencies.push({
         name: "llama-index-agent-openai",
-        version: "0.3.0",
+        version: ">=0.4.0,<0.5.0",
       });
       dependencies.push({
         name: "llama-index-llms-openai-like",
-        version: "0.2.0",
+        version: ">=0.3.0,<0.4.0",
       });
       break;
   }
 
-  return dependencies;
-};
-
-const mergePoetryDependencies = (
-  dependencies: Dependency[],
-  existingDependencies: Record<string, Omit<Dependency, "name"> | string>,
-) => {
-  for (const dependency of dependencies) {
-    let value = existingDependencies[dependency.name] ?? {};
-
-    // default string value is equal to attribute "version"
-    if (typeof value === "string") {
-      value = { version: value };
+  if (observability && observability !== "none") {
+    if (observability === "traceloop") {
+      dependencies.push({
+        name: "traceloop-sdk",
+        version: ">=0.15.11",
+      });
     }
-
-    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"!`,
-      );
-    }
-
-    // Serialize separately only if extras are provided
-    if (value.extras && value.extras.length > 0) {
-      existingDependencies[dependency.name] = value;
-    } else {
-      // Otherwise, serialize just the version string
-      existingDependencies[dependency.name] = value.version;
+    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[]) => {
@@ -317,19 +303,100 @@ export const addDependencies = async (
     // Parse toml file
     const file = path.join(projectDir, FILENAME);
     const fileContent = await fs.readFile(file, "utf8");
-    const fileParsed = parse(fileContent);
+    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.`,
+      );
+    }
 
-    // Modify toml dependencies
-    const tool = fileParsed.tool as any;
-    const existingDependencies = tool.poetry.dependencies;
-    mergePoetryDependencies(dependencies, existingDependencies);
+    // 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);
 
-    const dependenciesString = dependencies.map((d) => d.name).join(", ");
-    console.log(`\nAdded ${dependenciesString} to ${cyan(FILENAME)}\n`);
+    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`,
@@ -338,18 +405,16 @@ export const addDependencies = async (
   }
 };
 
-export const installPythonDependencies = (
-  { noRoot }: { noRoot: boolean } = { noRoot: false },
-) => {
-  if (isPoetryAvailable()) {
+export const installPythonDependencies = () => {
+  if (isUvAvailable()) {
     console.log(
-      `Installing python dependencies using poetry. This may take a while...`,
+      `Installing Python dependencies using uv. This may take a while...`,
     );
-    const installSuccessful = tryPoetryInstall(noRoot);
+    const installSuccessful = tryUvSync();
     if (!installSuccessful) {
       console.error(
         red(
-          "Installing dependencies using poetry failed. Please check error log above and try running create-llama again.",
+          "Installing dependencies using uv failed. Please check the error log above and ensure uv is installed correctly.",
         ),
       );
       process.exit(1);
@@ -357,53 +422,34 @@ export const installPythonDependencies = (
   } 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.`,
+        `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);
   }
 };
 
-export const installPythonTemplate = async ({
+const installLegacyPythonTemplate = async ({
   root,
   template,
-  framework,
   vectorDb,
   dataSources,
   tools,
-  postInstallAction,
+  useCase,
   observability,
-  modelConfig,
-  agents,
 }: Pick<
   InstallTemplateArgs,
   | "root"
-  | "framework"
   | "template"
   | "vectorDb"
   | "dataSources"
   | "tools"
-  | "postInstallAction"
+  | "useCase"
   | "observability"
-  | "modelConfig"
-  | "agents"
 >) => {
-  console.log("\nInitializing Python project with template:", template, "\n");
-  let templatePath;
-  if (template === "extractor") {
-    templatePath = path.join(templatesDir, "types", "extractor", framework);
-  } else {
-    templatePath = path.join(templatesDir, "types", "streaming", framework);
-  }
-  await copy("**", root, {
-    parents: true,
-    cwd: templatePath,
-    rename: assetRelocator,
-  });
-
   const compPath = path.join(templatesDir, "components");
   const enginePath = path.join(root, "app", "engine");
 
@@ -460,62 +506,40 @@ export const installPythonTemplate = async ({
       cwd: path.join(compPath, "engines", "python", engine),
     });
 
-    // Copy agent code
-    if (template === "multiagent") {
-      if (agents) {
-        await copy("**", path.join(root), {
-          parents: true,
-          cwd: path.join(compPath, "agents", "python", agents),
-          rename: assetRelocator,
-        });
-      } else {
-        console.log(
-          red(
-            "There is no agent selected for multi-agent template. Please pick an agent to use via --agents flag.",
-          ),
-        );
-        process.exit(1);
-      }
-    }
-
     // Copy router code
     await copyRouterCode(root, tools ?? []);
   }
 
+  // Copy multiagents overrides
   if (template === "multiagent") {
-    // Copy multi-agent code
     await copy("**", path.join(root), {
-      parents: true,
       cwd: path.join(compPath, "multiagent", "python"),
-      rename: assetRelocator,
     });
   }
 
-  console.log("Adding additional dependencies");
+  if (template === "multiagent" || template === "reflex") {
+    if (useCase) {
+      const sourcePath =
+        template === "multiagent"
+          ? path.join(compPath, "agents", "python", useCase)
+          : path.join(compPath, "reflex", useCase);
 
-  const addOnDependencies = getAdditionalDependencies(
-    modelConfig,
-    vectorDb,
-    dataSources,
-    tools,
-    template,
-  );
+      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") {
-    if (observability === "traceloop") {
-      addOnDependencies.push({
-        name: "traceloop-sdk",
-        version: "^0.15.11",
-      });
-    }
-
-    if (observability === "llamatrace") {
-      addOnDependencies.push({
-        name: "llama-index-callbacks-arize-phoenix",
-        version: "^0.2.1",
-      });
-    }
-
     const templateObservabilityPath = path.join(
       templatesDir,
       "components",
@@ -527,15 +551,138 @@ export const installPythonTemplate = async ({
       cwd: templateObservabilityPath,
     });
   }
+};
+
+const installLlamaIndexServerTemplate = async ({
+  root,
+  useCase,
+  useLlamaParse,
+}: Pick<InstallTemplateArgs, "root" | "useCase" | "useLlamaParse">) => {
+  if (!useCase) {
+    console.log(
+      red(
+        `There is no use case selected. Please pick a use case to use via --use-case flag.`,
+      ),
+    );
+    process.exit(1);
+  }
+
+  await copy("*.py", path.join(root, "app"), {
+    parents: true,
+    cwd: path.join(templatesDir, "components", "use-cases", "python", useCase),
+  });
+
+  // Copy custom UI component code
+  await copy(`*`, path.join(root, "components"), {
+    parents: true,
+    cwd: path.join(templatesDir, "components", "ui", "use-cases", useCase),
+  });
+
+  if (useLlamaParse) {
+    await copy("index.py", path.join(root, "app"), {
+      parents: true,
+      cwd: path.join(
+        templatesDir,
+        "components",
+        "vectordbs",
+        "llamaindexserver",
+        "llamacloud",
+        "python",
+      ),
+    });
+    // TODO: Consider moving generate.py to app folder.
+    await copy("generate.py", path.join(root), {
+      parents: true,
+      cwd: path.join(
+        templatesDir,
+        "components",
+        "vectordbs",
+        "llamaindexserver",
+        "llamacloud",
+        "python",
+      ),
+    });
+  }
+  // Copy README.md
+  await copy("README-template.md", path.join(root), {
+    parents: true,
+    cwd: path.join(templatesDir, "components", "use-cases", "python", useCase),
+    rename: assetRelocator,
+  });
+};
+
+export const installPythonTemplate = async ({
+  appName,
+  root,
+  template,
+  framework,
+  vectorDb,
+  postInstallAction,
+  modelConfig,
+  dataSources,
+  tools,
+  useLlamaParse,
+  useCase,
+  observability,
+}: Pick<
+  InstallTemplateArgs,
+  | "appName"
+  | "root"
+  | "template"
+  | "framework"
+  | "vectorDb"
+  | "postInstallAction"
+  | "modelConfig"
+  | "dataSources"
+  | "tools"
+  | "useLlamaParse"
+  | "useCase"
+  | "observability"
+>) => {
+  console.log("\nInitializing Python project with template:", template, "\n");
+  let templatePath;
+  if (template === "reflex") {
+    templatePath = path.join(templatesDir, "types", "reflex");
+  } else {
+    templatePath = path.join(templatesDir, "types", template, framework);
+  }
+  await copy("**", root, {
+    parents: true,
+    cwd: templatePath,
+    rename: assetRelocator,
+  });
+
+  if (template === "llamaindexserver") {
+    await installLlamaIndexServerTemplate({
+      root,
+      useCase,
+      useLlamaParse,
+    });
+  } else {
+    await installLegacyPythonTemplate({
+      root,
+      template,
+      vectorDb,
+      dataSources,
+      tools,
+      useCase,
+      observability,
+    });
+  }
+
+  console.log("Adding additional dependencies");
+  const addOnDependencies = getAdditionalDependencies(
+    modelConfig,
+    vectorDb,
+    dataSources,
+    tools,
+    template,
+    observability,
+  );
 
   await addDependencies(root, addOnDependencies);
 
   if (postInstallAction === "runApp" || postInstallAction === "dependencies") {
     installPythonDependencies();
   }
-
-  // Copy deployment files for python
-  await copy("**", root, {
-    cwd: path.join(compPath, "deployments", "python"),
-  });
 };

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

@@ -0,0 +1,91 @@
+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

@@ -41,7 +41,7 @@ export const supportedTools: Tool[] = [
     dependencies: [
       {
         name: "llama-index-tools-google",
-        version: "^0.2.0",
+        version: ">=0.3.0,<0.4.0",
       },
     ],
     supportedFrameworks: ["fastapi"],
@@ -62,17 +62,16 @@ export const supportedTools: Tool[] = [
     dependencies: [
       {
         name: "duckduckgo-search",
-        version: "6.1.7",
+        version: ">=6.3.5,<7.0.0",
       },
     ],
-    supportedFrameworks: ["fastapi", "nextjs", "express"],
+    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 are a DuckDuckGo search agent. 
-You can use the duckduckgo search tool to get information from the web to answer user questions.
+        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.`,
       },
     ],
@@ -83,18 +82,11 @@ For better results, you can specify the region parameter to get results from a s
     dependencies: [
       {
         name: "llama-index-tools-wikipedia",
-        version: "^0.2.0",
+        version: ">=0.3.0,<0.4.0",
       },
     ],
     supportedFrameworks: ["fastapi", "express", "nextjs"],
     type: ToolType.LLAMAHUB,
-    envVars: [
-      {
-        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
-        description: "System prompt for wiki tool.",
-        value: `You are a Wikipedia agent. You help users to get information from Wikipedia.`,
-      },
-    ],
   },
   {
     display: "Weather",
@@ -102,13 +94,6 @@ For better results, you can specify the region parameter to get results from a s
     dependencies: [],
     supportedFrameworks: ["fastapi", "express", "nextjs"],
     type: ToolType.LOCAL,
-    envVars: [
-      {
-        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
-        description: "System prompt for weather tool.",
-        value: `You are a weather forecast agent. You help users to get the weather forecast for a given location.`,
-      },
-    ],
   },
   {
     display: "Document generator",
@@ -117,11 +102,11 @@ For better results, you can specify the region parameter to get results from a s
     dependencies: [
       {
         name: "xhtml2pdf",
-        version: "^0.2.14",
+        version: ">=0.2.14,<0.3.0",
       },
       {
         name: "markdown",
-        version: "^3.7",
+        version: ">=3.7.0,<4.0.0",
       },
     ],
     type: ToolType.LOCAL,
@@ -139,7 +124,7 @@ For better results, you can specify the region parameter to get results from a s
     dependencies: [
       {
         name: "e2b_code_interpreter",
-        version: "0.0.11b38",
+        version: ">=1.1.1,<1.2.0",
       },
     ],
     supportedFrameworks: ["fastapi", "express", "nextjs"],
@@ -170,7 +155,7 @@ For better results, you can specify the region parameter to get results from a s
     dependencies: [
       {
         name: "e2b_code_interpreter",
-        version: "0.0.11b38",
+        version: ">=1.1.1,<1.2.0",
       },
     ],
     supportedFrameworks: ["fastapi", "express", "nextjs"],
@@ -199,7 +184,7 @@ For better results, you can specify the region parameter to get results from a s
       },
       {
         name: "jsonschema",
-        version: "^4.22.0",
+        version: ">=4.22.0,<5.0.0",
       },
       {
         name: "llama-index-tools-requests",
@@ -211,14 +196,6 @@ For better results, you can specify the region parameter to get results from a s
     },
     supportedFrameworks: ["fastapi", "express", "nextjs"],
     type: ToolType.LOCAL,
-    envVars: [
-      {
-        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
-        description: "System prompt for openapi action tool.",
-        value:
-          "You are an OpenAPI action agent. You help users to make requests to the provided OpenAPI schema.",
-      },
-    ],
   },
   {
     display: "Image Generator",
@@ -231,11 +208,6 @@ For better results, you can specify the region parameter to get results from a s
         description:
           "STABILITY_API_KEY key is required to run image generator. Get it here: https://platform.stability.ai/account/keys",
       },
-      {
-        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
-        description: "System prompt for image generator tool.",
-        value: `You are an image generator agent. You help users to generate images using the Stability API.`,
-      },
     ],
   },
   {
@@ -275,11 +247,11 @@ For better results, you can specify the region parameter to get results from a s
     dependencies: [
       {
         name: "pandas",
-        version: "^2.2.3",
+        version: ">=2.2.3,<3.0.0",
       },
       {
         name: "tabulate",
-        version: "^0.9.0",
+        version: ">=0.9.0,<1.0.0",
       },
     ],
   },
@@ -353,9 +325,16 @@ export const writeToolsConfig = async (
       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(configContent, null, 2),
+      JSON.stringify(tsConfigContent, null, 2),
     );
   }
 };

packages/create-llama/helpers/types.ts

@@ -20,11 +20,12 @@ export type ModelConfig = {
   isConfigured(): boolean;
 };
 export type TemplateType =
-  | "extractor"
   | "streaming"
   | "community"
   | "llamapack"
-  | "multiagent";
+  | "multiagent"
+  | "reflex"
+  | "llamaindexserver";
 export type TemplateFramework = "nextjs" | "express" | "fastapi";
 export type TemplateUI = "html" | "shadcn";
 export type TemplateVectorDB =
@@ -49,14 +50,25 @@ export type TemplateDataSource = {
 };
 export type TemplateDataSourceType = "file" | "web" | "db";
 export type TemplateObservability = "none" | "traceloop" | "llamatrace";
-export type TemplateAgents = "financial_report" | "blog" | "form_filling";
+export type TemplateUseCase =
+  | "financial_report"
+  | "blog"
+  | "deep_research"
+  | "form_filling"
+  | "extractor"
+  | "contract_review"
+  | "agentic_rag"
+  | "code_generator"
+  | "document_generator";
 // Config for both file and folder
 export type FileSourceConfig =
   | {
       path: string;
+      filename?: string;
     }
   | {
       url: URL;
+      filename?: string;
     };
 export type WebSourceConfig = {
   baseUrl?: string;
@@ -89,16 +101,15 @@ export interface InstallTemplateArgs {
   framework: TemplateFramework;
   ui: TemplateUI;
   dataSources: TemplateDataSource[];
-  customApiPath?: string;
   modelConfig: ModelConfig;
   llamaCloudKey?: string;
   useLlamaParse?: boolean;
   communityProjectConfig?: CommunityProjectConfig;
   llamapack?: string;
   vectorDb?: TemplateVectorDB;
-  externalPort?: number;
+  port?: number;
   postInstallAction?: TemplatePostInstallAction;
   tools?: Tool[];
   observability?: TemplateObservability;
-  agents?: TemplateAgents;
+  useCase?: TemplateUseCase;
 }

packages/create-llama/helpers/typescript.ts

@@ -6,43 +6,103 @@ import { assetRelocator, copy } from "../helpers/copy";
 import { callPackageManager } from "../helpers/install";
 import { templatesDir } from "./dir";
 import { PackageManager } from "./get-pkg-manager";
-import { InstallTemplateArgs } from "./types";
+import { InstallTemplateArgs, ModelProvider, TemplateVectorDB } from "./types";
 
-/**
- * Install a LlamaIndex internal template to a given `root` directory.
- */
-export const installTSTemplate = async ({
-  appName,
+const installLlamaIndexServerTemplate = async ({
+  root,
+  useCase,
+  vectorDb,
+}: Pick<InstallTemplateArgs, "root" | "useCase" | "vectorDb">) => {
+  if (!useCase) {
+    console.log(
+      red(
+        `There is no use case selected. Please pick a use case to use via --use-case flag.`,
+      ),
+    );
+    process.exit(1);
+  }
+
+  if (!vectorDb) {
+    console.log(
+      red(
+        `There is no vector db selected. Please pick a vector db to use via --vector-db flag.`,
+      ),
+    );
+    process.exit(1);
+  }
+
+  await copy("**", path.join(root), {
+    cwd: path.join(
+      templatesDir,
+      "components",
+      "use-cases",
+      "typescript",
+      useCase,
+    ),
+    rename: assetRelocator,
+  });
+
+  // copy workflow UI components to output/components folder
+  await copy("*", path.join(root, "components"), {
+    parents: true,
+    cwd: path.join(templatesDir, "components", "ui", "use-cases", useCase),
+  });
+
+  // Override generate.ts if workflow use case doesn't use custom UI
+  if (vectorDb === "llamacloud") {
+    await copy("generate.ts", path.join(root, "src"), {
+      parents: true,
+      cwd: path.join(
+        templatesDir,
+        "components",
+        "vectordbs",
+        "llamaindexserver",
+        "llamacloud",
+        "typescript",
+      ),
+    });
+
+    await copy("index.ts", path.join(root, "src", "app"), {
+      parents: true,
+      cwd: path.join(
+        templatesDir,
+        "components",
+        "vectordbs",
+        "llamaindexserver",
+        "llamacloud",
+        "typescript",
+      ),
+      rename: () => "data.ts",
+    });
+  }
+
+  // Simplify use case code
+  if (useCase === "code_generator" || useCase === "document_generator") {
+    // Artifact use case doesn't use index.
+    // We don't need data.ts, generate.ts
+    await fs.rm(path.join(root, "src", "app", "data.ts"));
+    // TODO: Remove generate index in generate.ts and package.json if possible
+  }
+};
+
+const installLegacyTSTemplate = async ({
   root,
-  packageManager,
-  isOnline,
   template,
+  backend,
   framework,
   ui,
   vectorDb,
-  postInstallAction,
-  backend,
   observability,
   tools,
   dataSources,
   useLlamaParse,
-  agents,
-}: InstallTemplateArgs & { backend: boolean }) => {
-  console.log(bold(`Using ${packageManager}.`));
-
-  /**
-   * Copy the template files to the target directory.
-   */
-  console.log("\nInitializing project with template:", template, "\n");
-  const templatePath = path.join(templatesDir, "types", "streaming", framework);
-  const copySource = ["**"];
-
-  await copy(copySource, root, {
-    parents: true,
-    cwd: templatePath,
-    rename: assetRelocator,
-  });
-
+  useCase,
+  modelConfig,
+  relativeEngineDestPath,
+}: InstallTemplateArgs & {
+  backend: boolean;
+  relativeEngineDestPath: string;
+}) => {
   /**
    * If next.js is used, update its configuration if necessary
    */
@@ -58,11 +118,9 @@ export const installTSTemplate = async ({
       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",
-        );
+        nextConfigJson.serverExternalPackages =
+          nextConfigJson.serverExternalPackages ?? [];
+        nextConfigJson.serverExternalPackages.push("@zilliz/milvus2-sdk-node");
       }
     }
     await fs.writeFile(
@@ -99,10 +157,6 @@ export const installTSTemplate = async ({
   }
 
   const compPath = path.join(templatesDir, "components");
-  const relativeEngineDestPath =
-    framework === "nextjs"
-      ? path.join("app", "api", "chat")
-      : path.join("src", "controllers");
   const enginePath = path.join(root, relativeEngineDestPath, "engine");
 
   // copy llamaindex code for TS templates
@@ -133,16 +187,16 @@ export const installTSTemplate = async ({
       cwd: path.join(multiagentPath, "workflow"),
     });
 
-    // Copy agents use case code for multiagent template
-    if (agents) {
-      console.log("\nCopying agent:", agents, "\n");
-      const useCasePath = path.join(compPath, "agents", "typescript", agents);
-      const agentsCodePath = path.join(useCasePath, "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 agent codes
+      // Copy use case codes
       await copy("**", path.join(root, relativeEngineDestPath, "workflow"), {
         parents: true,
-        cwd: agentsCodePath,
+        cwd: useCaseCodePath,
         rename: assetRelocator,
       });
 
@@ -155,7 +209,7 @@ export const installTSTemplate = async ({
     } else {
       console.log(
         red(
-          "There is no agent selected for multi-agent template. Please pick an agent to use via --agents flag.",
+          `There is no use case selected for ${template} template. Please pick a use case to use via --use-case flag.`,
         ),
       );
       process.exit(1);
@@ -183,6 +237,12 @@ export const installTSTemplate = async ({
     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 ?? [];
@@ -231,6 +291,75 @@ export const installTSTemplate = async ({
     await fs.rm(path.join(root, "app", "api"), { recursive: true });
     await fs.rm(path.join(root, "config"), { recursive: true, force: true });
   }
+};
+
+/**
+ * Install a LlamaIndex internal template to a given `root` directory.
+ */
+export const installTSTemplate = async ({
+  appName,
+  root,
+  packageManager,
+  isOnline,
+  template,
+  framework,
+  ui,
+  vectorDb,
+  postInstallAction,
+  backend,
+  observability,
+  tools,
+  dataSources,
+  useLlamaParse,
+  useCase,
+  modelConfig,
+}: InstallTemplateArgs & { backend: boolean }) => {
+  console.log(bold(`Using ${packageManager}.`));
+
+  /**
+   * Copy the template files to the target directory.
+   */
+  console.log("\nInitializing project with template:", template, "\n");
+  const templatePath = path.join(templatesDir, "types", template, framework);
+  const copySource = ["**"];
+
+  await copy(copySource, root, {
+    parents: true,
+    cwd: templatePath,
+    rename: assetRelocator,
+  });
+
+  const relativeEngineDestPath =
+    framework === "nextjs"
+      ? path.join("app", "api", "chat")
+      : path.join("src", "controllers");
+
+  if (template === "llamaindexserver") {
+    await installLlamaIndexServerTemplate({
+      root,
+      useCase,
+      vectorDb,
+    });
+  } else {
+    await installLegacyTSTemplate({
+      appName,
+      root,
+      packageManager,
+      isOnline,
+      template,
+      backend,
+      framework,
+      ui,
+      vectorDb,
+      observability,
+      tools,
+      dataSources,
+      useLlamaParse,
+      useCase,
+      modelConfig,
+      relativeEngineDestPath,
+    });
+  }
 
   const packageJson = await updatePackageJson({
     root,
@@ -241,16 +370,79 @@ export const installTSTemplate = async ({
     ui,
     observability,
     vectorDb,
+    backend,
+    modelConfig,
+    template,
   });
 
-  if (postInstallAction === "runApp" || postInstallAction === "dependencies") {
+  if (
+    backend &&
+    (postInstallAction === "runApp" || postInstallAction === "dependencies")
+  ) {
     await installTSDependencies(packageJson, packageManager, isOnline);
   }
+};
 
-  // Copy deployment files for typescript
-  await copy("**", root, {
-    cwd: path.join(compPath, "deployments", "typescript"),
-  });
+const providerDependencies: {
+  [key in ModelProvider]?: Record<string, string>;
+} = {
+  openai: {
+    "@llamaindex/openai": "~0.4.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({
@@ -262,6 +454,9 @@ async function updatePackageJson({
   ui,
   observability,
   vectorDb,
+  backend,
+  modelConfig,
+  template,
 }: Pick<
   InstallTemplateArgs,
   | "root"
@@ -271,8 +466,11 @@ async function updatePackageJson({
   | "ui"
   | "observability"
   | "vectorDb"
+  | "modelConfig"
+  | "template"
 > & {
   relativeEngineDestPath: string;
+  backend: boolean;
 }): Promise<any> {
   const packageJsonFile = path.join(root, "package.json");
   const packageJson: any = JSON.parse(
@@ -281,7 +479,7 @@ async function updatePackageJson({
   packageJson.name = appName;
   packageJson.version = "0.1.0";
 
-  if (relativeEngineDestPath) {
+  if (relativeEngineDestPath && template !== "llamaindexserver") {
     // TODO: move script to {root}/scripts for all frameworks
     // add generate script if using context engine
     packageJson.scripts = {
@@ -312,32 +510,25 @@ async function updatePackageJson({
     };
   }
 
-  if (vectorDb === "pg") {
+  if (backend) {
     packageJson.dependencies = {
       ...packageJson.dependencies,
-      pg: "^8.12.0",
-      pgvector: "^0.2.0",
+      "@llamaindex/readers": "~3.1.4",
     };
-  }
 
-  if (vectorDb === "qdrant") {
-    packageJson.dependencies = {
-      ...packageJson.dependencies,
-      "@qdrant/js-client-rest": "^1.11.0",
-    };
-  }
-  if (vectorDb === "mongo") {
-    packageJson.dependencies = {
-      ...packageJson.dependencies,
-      mongodb: "^6.7.0",
-    };
-  }
+    if (vectorDb && vectorDb in vectorDbDependencies) {
+      packageJson.dependencies = {
+        ...packageJson.dependencies,
+        ...vectorDbDependencies[vectorDb],
+      };
+    }
 
-  if (vectorDb === "milvus") {
-    packageJson.dependencies = {
-      ...packageJson.dependencies,
-      "@zilliz/milvus2-sdk-node": "^2.4.6",
-    };
+    if (modelConfig.provider && modelConfig.provider in providerDependencies) {
+      packageJson.dependencies = {
+        ...packageJson.dependencies,
+        ...providerDependencies[modelConfig.provider],
+      };
+    }
   }
 
   if (observability === "traceloop") {
@@ -352,6 +543,16 @@ async function updatePackageJson({
     };
   }
 
+  // if having custom server package tgz file, use it for testing @llamaindex/server
+  const serverPackagePath = process.env.SERVER_PACKAGE_PATH;
+  if (serverPackagePath && template === "llamaindexserver") {
+    const relativePath = path.relative(process.cwd(), serverPackagePath);
+    packageJson.dependencies = {
+      ...packageJson.dependencies,
+      "@llamaindex/server": `file:${relativePath}`,
+    };
+  }
+
   await fs.writeFile(
     packageJsonFile,
     JSON.stringify(packageJson, null, 2) + os.EOL,

packages/create-llama/helpers/uv.ts

@@ -0,0 +1,42 @@
+// 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/validate-pkg.ts

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

packages/create-llama/helpers/vscode.ts

@@ -1,40 +1,26 @@
 import fs from "fs";
 import path from "path";
+import { assetRelocator, copy } from "./copy";
 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";
-  }
+  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}",
-      };
-    }
+    devcontainerJson.containerEnv = {
+      ...devcontainerJson.containerEnv,
+      PYTHONPATH: "${PYTHONPATH}:${workspaceFolder}",
+    };
   }
 
   return JSON.stringify(devcontainerJson, null, 2);
@@ -44,7 +30,6 @@ export const writeDevcontainer = async (
   root: string,
   templatesDir: string,
   framework: TemplateFramework,
-  frontend: boolean,
 ) => {
   const devcontainerDir = path.join(root, ".devcontainer");
   if (fs.existsSync(devcontainerDir)) {
@@ -54,7 +39,6 @@ export const writeDevcontainer = async (
   const devcontainerContent = renderDevcontainerContent(
     templatesDir,
     framework,
-    frontend,
   );
   fs.mkdirSync(devcontainerDir);
   await fs.promises.writeFile(
@@ -62,3 +46,25 @@ export const writeDevcontainer = async (
     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/index.ts

@@ -1,4 +1,3 @@
-/* eslint-disable import/no-extraneous-dependencies */
 import { execSync } from "child_process";
 import { Command } from "commander";
 import fs from "fs";
@@ -134,13 +133,6 @@ const program = new Command(packageJson.name)
     `
 
   Select UI port.
-`,
-  )
-  .option(
-    "--external-port <external>",
-    `
-
-  Select external port.
 `,
   )
   .option(
@@ -204,15 +196,15 @@ const program = new Command(packageJson.name)
     "--pro",
     `
 
-  Allow interactive selection of all features.
+  Deprecated: Allow interactive selection of all features.
 `,
     false,
   )
   .option(
-    "--agents <agents>",
+    "--use-case <useCase>",
     `
 
-  Select which agents to use for the multi-agent template (e.g: financial_report, blog).
+  Select which use case to use for the multi-agent template (e.g: financial_report, blog).
 `,
   )
   .allowUnknownOption()
@@ -222,7 +214,7 @@ const options = program.opts();
 
 if (
   process.argv.includes("--no-llama-parse") ||
-  options.template === "extractor"
+  options.template === "reflex"
 ) {
   options.useLlamaParse = false;
 }
@@ -333,7 +325,6 @@ async function run(): Promise<void> {
     ...answers,
     appPath: resolvedProjectPath,
     packageManager,
-    externalPort: options.externalPort,
   });
 
   if (answers.postInstallAction === "VSCode") {
@@ -362,14 +353,7 @@ Please check ${cyan(
     }
   } else if (answers.postInstallAction === "runApp") {
     console.log(`Running app in ${root}...`);
-    await runApp(
-      root,
-      answers.template,
-      answers.frontend,
-      answers.framework,
-      options.port,
-      options.externalPort,
-    );
+    await runApp(root, answers.template, answers.framework, options.port);
   }
 }
 

packages/create-llama/package.json

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

packages/create-llama/playwright.config.ts

@@ -1,4 +1,3 @@
-/* eslint-disable turbo/no-undeclared-env-vars */
 import { defineConfig, devices } from "@playwright/test";
 
 export default defineConfig({

packages/create-llama/questions/ci.ts

@@ -6,7 +6,7 @@ const defaults: Omit<QuestionArgs, "modelConfig"> = {
   framework: "nextjs",
   ui: "shadcn",
   frontend: false,
-  llamaCloudKey: "",
+  llamaCloudKey: undefined,
   useLlamaParse: false,
   communityProjectConfig: undefined,
   llamapack: "",

packages/create-llama/questions/datasources.ts

@@ -49,7 +49,7 @@ export const getDataSourceChoices = (
     );
   }
 
-  if (framework === "fastapi" && template !== "extractor") {
+  if (framework === "fastapi" && template !== "reflex") {
     choices.push({
       title: "Use website content (requires Chrome)",
       value: "web",

packages/create-llama/questions/index.ts

@@ -1,18 +1,28 @@
 import ciInfo from "ci-info";
+import { bold, yellow } from "picocolors";
 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 (ciInfo.isCI || process.env.PLAYWRIGHT_TEST === "1") {
+  if (isCI) {
     return await getCIQuestionResults(args);
   } else if (args.pro) {
     // TODO: refactor pro questions to return a result object
+    console.log(
+      yellow(
+        `Pro mode is deprecated. Please use the new templates using the ${bold("LlamaIndexServer")} by not specifying pro mode.`,
+      ),
+    );
+
     await askProQuestions(args);
     return args as unknown as QuestionResults;
   }
-  return await askSimpleQuestions(args);
+  const results = await askSimpleQuestions(args);
+  return results;
 };

packages/create-llama/questions/questions.ts

@@ -1,7 +1,8 @@
-import { blue, green } from "picocolors";
+import { blue } from "picocolors";
 import prompts from "prompts";
+import { isCI } from ".";
 import { COMMUNITY_OWNER, COMMUNITY_REPO } from "../helpers/constant";
-import { EXAMPLE_FILE } from "../helpers/datasources";
+import { EXAMPLE_FILE, EXAMPLE_GDPR } from "../helpers/datasources";
 import { getAvailableLlamapackOptions } from "../helpers/llama-pack";
 import { askModelConfig } from "../helpers/providers";
 import { getProjectOptions } from "../helpers/repo";
@@ -32,7 +33,7 @@ export const askProQuestions = async (program: QuestionArgs) => {
             title: "Multi-agent app (using workflows)",
             value: "multiagent",
           },
-          { title: "Structured Extractor", value: "extractor" },
+          { title: "Fullstack python template with Reflex", value: "reflex" },
           {
             title: `Community template from ${styledRepo}`,
             value: "community",
@@ -94,11 +95,29 @@ export const askProQuestions = async (program: QuestionArgs) => {
     return; // early return - no further questions needed for llamapack projects
   }
 
-  if (program.template === "extractor") {
-    // Extractor template only supports FastAPI, empty data sources, and llamacloud
+  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) {
@@ -122,24 +141,17 @@ export const askProQuestions = async (program: QuestionArgs) => {
   }
 
   if (
-    (program.framework === "express" || program.framework === "fastapi") &&
+    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 styledBackend = green(
-        program.framework === "express"
-          ? "Express "
-          : program.framework === "fastapi"
-            ? "FastAPI (Python) "
-            : "",
-      );
       const { frontend } = await prompts({
         onState: onPromptState,
         type: "toggle",
         name: "frontend",
-        message: `Would you like to generate a ${styledNextJS} frontend for your ${styledBackend}backend?`,
+        message: `Would you like to generate a ${styledNextJS} frontend for your FastAPI backend?`,
         initial: false,
         active: "Yes",
         inactive: "No",
@@ -177,32 +189,50 @@ export const askProQuestions = async (program: QuestionArgs) => {
     program.observability = observability;
   }
 
-  // Ask agents
-  if (program.template === "multiagent" && !program.agents) {
-    const { agents } = await prompts(
+  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: "agents",
-        message: "Which agents would you like to use?",
-        choices: [
-          {
-            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_writer",
-          },
-        ],
+        name: "useCase",
+        message: "Which use case would you like to use?",
+        choices,
         initial: 0,
       },
       questionHandlers,
     );
-    program.agents = agents;
+    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) {
@@ -228,8 +258,8 @@ export const askProQuestions = async (program: QuestionArgs) => {
     program.vectorDb = vectorDb;
   }
 
-  if (program.vectorDb === "llamacloud") {
-    // When using a LlamaCloud index, don't ask for data sources just copy an example file
+  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];
   }
 
@@ -360,11 +390,8 @@ export const askProQuestions = async (program: QuestionArgs) => {
     // default to use LlamaParse if using LlamaCloud
     program.useLlamaParse = true;
   } else {
-    // Extractor template doesn't support LlamaParse and LlamaCloud right now (cannot use asyncio loop in Reflex)
-    if (
-      program.useLlamaParse === undefined &&
-      program.template !== "extractor"
-    ) {
+    // 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(
@@ -386,7 +413,7 @@ export const askProQuestions = async (program: QuestionArgs) => {
 
   // Ask for LlamaCloud API key when using a LlamaCloud index or LlamaParse
   if (isUsingLlamaCloud || program.useLlamaParse) {
-    if (!program.llamaCloudKey) {
+    if (!program.llamaCloudKey && !isCI) {
       // if already set, don't ask again
       // Ask for LlamaCloud API key
       const { llamaCloudKey } = await prompts(

packages/create-llama/questions/simple.ts

@@ -7,12 +7,11 @@ import { PureQuestionArgs, QuestionResults } from "./types";
 import { askPostInstallAction, questionHandlers } from "./utils";
 
 type AppType =
-  | "rag"
-  | "code_artifact"
-  | "financial_report_agent"
-  | "form_filling"
-  | "extractor"
-  | "data_scientist";
+  | "agentic_rag"
+  | "financial_report"
+  | "deep_research"
+  | "code_generator"
+  | "document_generator";
 
 type SimpleAnswers = {
   appType: AppType;
@@ -28,20 +27,36 @@ export const askSimpleQuestions = async (
     {
       type: "select",
       name: "appType",
-      message: "What app do you want to build?",
+      message: "What use case do you want to build?",
       choices: [
-        { title: "Agentic RAG", value: "rag" },
-        { title: "Data Scientist", value: "data_scientist" },
         {
-          title: "Financial Report Generator (using Workflows)",
-          value: "financial_report_agent",
+          title: "Agentic RAG",
+          value: "agentic_rag",
+          description:
+            "Chatbot that answers questions based on provided documents.",
         },
         {
-          title: "Form Filler (using Workflows)",
-          value: "form_filling",
+          title: "Financial Report",
+          value: "financial_report",
+          description:
+            "Agent that analyzes data and generates visualizations by using a code interpreter.",
+        },
+        {
+          title: "Deep Research",
+          value: "deep_research",
+          description:
+            "Researches and analyzes provided documents from multiple perspectives, generating a comprehensive report with citations to support key findings and insights.",
+        },
+        {
+          title: "Code Generator",
+          value: "code_generator",
+          description: "Build a Vercel v0 styled code generator.",
+        },
+        {
+          title: "Document Generator",
+          value: "document_generator",
+          description: "Build a OpenAI canvas-styled document generator.",
         },
-        { title: "Code Artifact Agent", value: "code_artifact" },
-        { title: "Information Extractor", value: "extractor" },
       ],
     },
     questionHandlers,
@@ -49,23 +64,24 @@ export const askSimpleQuestions = async (
 
   let language: TemplateFramework = "fastapi";
   let llamaCloudKey = args.llamaCloudKey;
+
   let useLlamaCloud = false;
 
-  if (appType !== "extractor") {
-    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 { language: newLanguage } = await prompts(
+    {
+      type: "select",
+      name: "language",
+      message: "What language do you want to use?",
+      choices: [
+        { title: "Python (FastAPI)", value: "fastapi" },
+        { title: "Typescript (NextJS)", value: "nextjs" },
+      ],
+    },
+    questionHandlers,
+  );
+  language = newLanguage;
 
+  if (appType !== "code_generator" && appType !== "document_generator") {
     const { useLlamaCloud: newUseLlamaCloud } = await prompts(
       {
         type: "toggle",
@@ -79,20 +95,20 @@ export const askSimpleQuestions = async (
       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;
-    }
+  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, {
@@ -110,10 +126,10 @@ const convertAnswers = async (
   args: PureQuestionArgs,
   answers: SimpleAnswers,
 ): Promise<QuestionResults> => {
-  const MODEL_GPT4o: ModelConfig = {
+  const MODEL_GPT41: ModelConfig = {
     provider: "openai",
     apiKey: args.openAiKey,
-    model: "gpt-4o",
+    model: "gpt-4.1",
     embeddingModel: "text-embedding-3-large",
     dimensions: 1536,
     isConfigured(): boolean {
@@ -122,65 +138,48 @@ const convertAnswers = async (
   };
   const lookup: Record<
     AppType,
-    Pick<
-      QuestionResults,
-      "template" | "tools" | "frontend" | "dataSources" | "agents"
-    > & {
+    Pick<QuestionResults, "template" | "tools" | "dataSources" | "useCase"> & {
       modelConfig?: ModelConfig;
     }
   > = {
-    rag: {
-      template: "streaming",
-      tools: getTools(["duckduckgo"]),
-      frontend: true,
+    agentic_rag: {
+      template: "llamaindexserver",
       dataSources: [EXAMPLE_FILE],
     },
-    data_scientist: {
-      template: "streaming",
+    financial_report: {
+      template: "llamaindexserver",
+      dataSources: EXAMPLE_10K_SEC_FILES,
       tools: getTools(["interpreter", "document_generator"]),
-      frontend: true,
-      dataSources: [],
-      modelConfig: MODEL_GPT4o,
+      modelConfig: MODEL_GPT41,
     },
-    code_artifact: {
-      template: "streaming",
-      tools: getTools(["artifact"]),
-      frontend: true,
-      dataSources: [],
-      modelConfig: MODEL_GPT4o,
-    },
-    financial_report_agent: {
-      template: "multiagent",
-      agents: "financial_report",
-      tools: getTools(["document_generator", "interpreter"]),
+    deep_research: {
+      template: "llamaindexserver",
       dataSources: EXAMPLE_10K_SEC_FILES,
-      frontend: true,
-      modelConfig: MODEL_GPT4o,
-    },
-    form_filling: {
-      template: "multiagent",
-      agents: "form_filling",
-      tools: getTools(["form_filling"]),
-      dataSources: EXAMPLE_10K_SEC_FILES,
-      frontend: true,
-      modelConfig: MODEL_GPT4o,
-    },
-    extractor: {
-      template: "extractor",
       tools: [],
-      frontend: false,
-      dataSources: [EXAMPLE_FILE],
+      modelConfig: MODEL_GPT41,
+    },
+    code_generator: {
+      template: "llamaindexserver",
+      dataSources: [],
+      tools: [],
+      modelConfig: MODEL_GPT41,
+    },
+    document_generator: {
+      template: "llamaindexserver",
+      dataSources: [],
+      tools: [],
+      modelConfig: MODEL_GPT41,
     },
   };
+
   const results = lookup[answers.appType];
   return {
     framework: answers.language,
+    useCase: answers.appType,
     ui: "shadcn",
     llamaCloudKey: answers.llamaCloudKey,
     useLlamaParse: answers.useLlamaCloud,
-    llamapack: "",
     vectorDb: answers.useLlamaCloud ? "llamacloud" : "none",
-    observability: "none",
     ...results,
     modelConfig:
       results.modelConfig ??
@@ -189,6 +188,6 @@ const convertAnswers = async (
         askModels: args.askModels ?? false,
         framework: answers.language,
       })),
-    frontend: answers.language === "nextjs" ? false : results.frontend,
+    frontend: true,
   };
 };

packages/create-llama/questions/types.ts

@@ -2,7 +2,7 @@ import { InstallAppArgs } from "../create-app";
 
 export type QuestionResults = Omit<
   InstallAppArgs,
-  "appPath" | "packageManager" | "externalPort"
+  "appPath" | "packageManager"
 >;
 
 export type PureQuestionArgs = {

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

@@ -19,20 +19,20 @@ First, setup the environment with poetry:
 > **_Note:_** This step is not needed if you are using the dev-container.
 
 ```shell
-poetry install
+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
-poetry run generate
+uv run generate
 ```
 
 Third, run the development server:
 
 ```shell
-poetry run python main.py
+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`.
@@ -47,14 +47,18 @@ curl --location 'localhost:8000/api/chat' \
 
 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/docs](http://localhost:8000/docs) with your browser to see the Swagger UI of the API.
+Open [http://localhost:8000](http://localhost:8000) with your browser to start the app.
 
-The API allows CORS for all origins to simplify development. You can change this behavior by setting the `ENVIRONMENT` environment variable to `prod`:
+To start the app optimized for **production**, run:
 
 ```
-ENVIRONMENT=prod poetry run python main.py
+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:

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

@@ -1,4 +1,3 @@
-import os
 from textwrap import dedent
 from typing import List
 
@@ -6,42 +5,24 @@ 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 llama_index.core.tools import QueryEngineTool, ToolMetadata
+from app.engine.tools.query_engine import get_query_engine_tool
 
 
-def _create_query_engine_tool(params=None) -> QueryEngineTool:
-    """
-    Provide an agent worker that can be used to query the index.
-    """
-    # Add query tool if index exists
-    index_config = IndexConfig(**(params or {}))
-    index = get_index(index_config)
-    if index is None:
-        return None
-    top_k = int(os.getenv("TOP_K", 0))
-    query_engine = index.as_query_engine(
-        **({"similarity_top_k": top_k} if top_k != 0 else {})
-    )
-    return QueryEngineTool(
-        query_engine=query_engine,
-        metadata=ToolMetadata(
-            name="query_index",
-            description="""
-                Use this tool to retrieve information about the text corpus from the index.
-            """,
-        ),
-    )
-
-
-def _get_research_tools(**kwargs) -> QueryEngineTool:
+def _get_research_tools(**kwargs):
     """
     Researcher take responsibility for retrieving information.
     Try init wikipedia or duckduckgo tool if available.
     """
     tools = []
-    query_engine_tool = _create_query_engine_tool(**kwargs)
-    if query_engine_tool is not None:
-        tools.append(query_engine_tool)
+    # 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",

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

@@ -317,7 +317,7 @@ class Planner:
         # 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" f"\t{task_output!s}\n"
+            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

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

@@ -0,0 +1,47 @@
+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

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

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

@@ -0,0 +1,183 @@
+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

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

@@ -0,0 +1,328 @@
+import logging
+import os
+import uuid
+from typing import Any, Dict, List, Optional
+
+from llama_index.core.indices.base import BaseIndex
+from llama_index.core.memory import ChatMemoryBuffer
+from llama_index.core.memory.simple_composable_memory import SimpleComposableMemory
+from llama_index.core.schema import Node
+from llama_index.core.types import ChatMessage, MessageRole
+from llama_index.core.workflow import (
+    Context,
+    StartEvent,
+    StopEvent,
+    Workflow,
+    step,
+)
+
+from app.engine.index import IndexConfig, get_index
+from app.workflows.agents import plan_research, research, write_report
+from app.workflows.events import SourceNodesEvent
+from app.workflows.models import (
+    CollectAnswersEvent,
+    DataEvent,
+    PlanResearchEvent,
+    ReportEvent,
+    ResearchEvent,
+)
+
+logger = logging.getLogger("uvicorn")
+logger.setLevel(logging.INFO)
+
+
+def create_workflow(
+    params: Optional[Dict[str, Any]] = None,
+    **kwargs,
+) -> Workflow:
+    index_config = IndexConfig(**params)
+    index = get_index(index_config)
+    if index is None:
+        raise ValueError(
+            "Index is not found. Try run generation script to create the index first."
+        )
+
+    return DeepResearchWorkflow(
+        index=index,
+        timeout=120.0,
+    )
+
+
+class DeepResearchWorkflow(Workflow):
+    """
+    A workflow to research and analyze documents from multiple perspectives and write a comprehensive report.
+
+    Requirements:
+    - An indexed documents containing the knowledge base related to the topic
+
+    Steps:
+    1. Retrieve information from the knowledge base
+    2. Analyze the retrieved information and provide questions for answering
+    3. Answer the questions
+    4. Write the report based on the research results
+    """
+
+    memory: SimpleComposableMemory
+    context_nodes: List[Node]
+    index: BaseIndex
+    user_request: str
+    stream: bool = True
+
+    def __init__(
+        self,
+        index: BaseIndex,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.index = index
+        self.context_nodes = []
+        self.memory = SimpleComposableMemory.from_defaults(
+            primary_memory=ChatMemoryBuffer.from_defaults(),
+        )
+
+    @step
+    async def retrieve(self, ctx: Context, ev: StartEvent) -> PlanResearchEvent:
+        """
+        Initiate the workflow: memory, tools, agent
+        """
+        self.stream = ev.get("stream", True)
+        self.user_request = ev.get("user_msg")
+        chat_history = ev.get("chat_history")
+        if chat_history is not None:
+            self.memory.put_messages(chat_history)
+
+        await ctx.set("total_questions", 0)
+
+        # Add user message to memory
+        self.memory.put_messages(
+            messages=[
+                ChatMessage(
+                    role=MessageRole.USER,
+                    content=self.user_request,
+                )
+            ]
+        )
+        ctx.write_event_to_stream(
+            DataEvent(
+                type="deep_research_event",
+                data={
+                    "event": "retrieve",
+                    "state": "inprogress",
+                },
+            )
+        )
+        retriever = self.index.as_retriever(
+            similarity_top_k=int(os.getenv("TOP_K", 10)),
+        )
+        nodes = retriever.retrieve(self.user_request)
+        self.context_nodes.extend(nodes)
+        ctx.write_event_to_stream(
+            DataEvent(
+                type="deep_research_event",
+                data={
+                    "event": "retrieve",
+                    "state": "done",
+                },
+            )
+        )
+        # Send source nodes to the stream
+        # Use SourceNodesEvent to display source nodes in the UI.
+        ctx.write_event_to_stream(
+            SourceNodesEvent(
+                nodes=nodes,
+            )
+        )
+        return PlanResearchEvent()
+
+    @step
+    async def analyze(
+        self, ctx: Context, ev: PlanResearchEvent
+    ) -> ResearchEvent | ReportEvent | StopEvent:
+        """
+        Analyze the retrieved information
+        """
+        logger.info("Analyzing the retrieved information")
+        ctx.write_event_to_stream(
+            DataEvent(
+                type="deep_research_event",
+                data={
+                    "event": "analyze",
+                    "state": "inprogress",
+                },
+            )
+        )
+        total_questions = await ctx.get("total_questions")
+        res = await plan_research(
+            memory=self.memory,
+            context_nodes=self.context_nodes,
+            user_request=self.user_request,
+            total_questions=total_questions,
+        )
+        if res.decision == "cancel":
+            ctx.write_event_to_stream(
+                DataEvent(
+                    type="deep_research_event",
+                    data={
+                        "event": "analyze",
+                        "state": "done",
+                    },
+                )
+            )
+            return StopEvent(
+                result=res.cancel_reason,
+            )
+        elif res.decision == "write":
+            # Writing a report without any research context is not allowed.
+            # It's a LLM hallucination.
+            if total_questions == 0:
+                ctx.write_event_to_stream(
+                    DataEvent(
+                        type="deep_research_event",
+                        data={
+                            "event": "analyze",
+                            "state": "done",
+                        },
+                    )
+                )
+                return StopEvent(
+                    result="Sorry, I have a problem when analyzing the retrieved information. Please try again.",
+                )
+
+            self.memory.put(
+                message=ChatMessage(
+                    role=MessageRole.ASSISTANT,
+                    content="No more idea to analyze. We should report the answers.",
+                )
+            )
+            ctx.send_event(ReportEvent())
+        else:
+            total_questions += len(res.research_questions)
+            await ctx.set("total_questions", total_questions)  # For tracking
+            await ctx.set(
+                "waiting_questions", len(res.research_questions)
+            )  # For waiting questions to be answered
+            self.memory.put(
+                message=ChatMessage(
+                    role=MessageRole.ASSISTANT,
+                    content="We need to find answers to the following questions:\n"
+                    + "\n".join(res.research_questions),
+                )
+            )
+            for question in res.research_questions:
+                question_id = str(uuid.uuid4())
+                ctx.write_event_to_stream(
+                    DataEvent(
+                        type="deep_research_event",
+                        data={
+                            "event": "answer",
+                            "state": "pending",
+                            "id": question_id,
+                            "question": question,
+                            "answer": None,
+                        },
+                    )
+                )
+                ctx.send_event(
+                    ResearchEvent(
+                        question_id=question_id,
+                        question=question,
+                        context_nodes=self.context_nodes,
+                    )
+                )
+        ctx.write_event_to_stream(
+            DataEvent(
+                type="deep_research_event",
+                data={
+                    "event": "analyze",
+                    "state": "done",
+                },
+            )
+        )
+        return None
+
+    @step(num_workers=2)
+    async def answer(self, ctx: Context, ev: ResearchEvent) -> CollectAnswersEvent:
+        """
+        Answer the question
+        """
+        ctx.write_event_to_stream(
+            DataEvent(
+                type="deep_research_event",
+                data={
+                    "event": "answer",
+                    "state": "inprogress",
+                    "id": ev.question_id,
+                    "question": ev.question,
+                },
+            )
+        )
+        try:
+            answer = await research(
+                context_nodes=ev.context_nodes,
+                question=ev.question,
+            )
+        except Exception as e:
+            logger.error(f"Error answering question {ev.question}: {e}")
+            answer = f"Got error when answering the question: {ev.question}"
+        ctx.write_event_to_stream(
+            DataEvent(
+                type="deep_research_event",
+                data={
+                    "event": "answer",
+                    "state": "done",
+                    "id": ev.question_id,
+                    "question": ev.question,
+                    "answer": answer,
+                },
+            )
+        )
+
+        return CollectAnswersEvent(
+            question_id=ev.question_id,
+            question=ev.question,
+            answer=answer,
+        )
+
+    @step
+    async def collect_answers(
+        self, ctx: Context, ev: CollectAnswersEvent
+    ) -> PlanResearchEvent:
+        """
+        Collect answers to all questions
+        """
+        num_questions = await ctx.get("waiting_questions")
+        results = ctx.collect_events(
+            ev,
+            expected=[CollectAnswersEvent] * num_questions,
+        )
+        if results is None:
+            return None
+        for result in results:
+            self.memory.put(
+                message=ChatMessage(
+                    role=MessageRole.ASSISTANT,
+                    content=f"<Question>{result.question}</Question>\n<Answer>{result.answer}</Answer>",
+                )
+            )
+        await ctx.set("waiting_questions", 0)
+        self.memory.put(
+            message=ChatMessage(
+                role=MessageRole.ASSISTANT,
+                content="Researched all the questions. Now, i need to analyze if it's ready to write a report or need to research more.",
+            )
+        )
+        return PlanResearchEvent()
+
+    @step
+    async def report(self, ctx: Context, ev: ReportEvent) -> StopEvent:
+        """
+        Report the answers
+        """
+        res = await write_report(
+            memory=self.memory,
+            user_request=self.user_request,
+            stream=self.stream,
+        )
+        return StopEvent(
+            result=res,
+        )

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

@@ -0,0 +1,43 @@
+from typing import List, Literal, Optional
+
+from llama_index.core.schema import NodeWithScore
+from llama_index.core.workflow import Event
+from pydantic import BaseModel
+
+
+# Workflow events
+class PlanResearchEvent(Event):
+    pass
+
+
+class ResearchEvent(Event):
+    question_id: str
+    question: str
+    context_nodes: List[NodeWithScore]
+
+
+class CollectAnswersEvent(Event):
+    question_id: str
+    question: str
+    answer: str
+
+
+class ReportEvent(Event):
+    pass
+
+
+# Events that are streamed to the frontend and rendered there
+class DeepResearchEventData(BaseModel):
+    event: Literal["retrieve", "analyze", "answer"]
+    state: Literal["pending", "inprogress", "done", "error"]
+    id: Optional[str] = None
+    question: Optional[str] = None
+    answer: Optional[str] = None
+
+
+class DataEvent(Event):
+    type: Literal["deep_research_event"]
+    data: DeepResearchEventData
+
+    def to_response(self):
+        return self.model_dump()

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

@@ -7,7 +7,7 @@ First, setup the environment with poetry:
 > **_Note:_** This step is not needed if you are using the dev-container.
 
 ```shell
-poetry install
+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 and `E2B_API_KEY` for the [E2B's code interpreter tool](https://e2b.dev/docs)).
@@ -15,13 +15,13 @@ Then check the parameters that have been pre-configured in the `.env` file in th
 Second, generate the embeddings of the documents in the `./data` directory:
 
 ```shell
-poetry run generate
+uv run generate
 ```
 
 Third, run the development server:
 
 ```shell
-poetry run python main.py
+uv run dev
 ```
 
 The example provides one streaming API endpoint `/api/chat`.
@@ -35,14 +35,18 @@ curl --location 'localhost:8000/api/chat' \
 
 You can start editing the API by modifying `app/api/routers/chat.py` or `app/workflows/financial_report.py`. The API auto-updates as you save the files.
 
-Open [http://localhost:8000/docs](http://localhost:8000/docs) with your browser to see the Swagger UI of the API.
+Open [http://localhost:8000](http://localhost:8000) with your browser to start the app.
 
-The API allows CORS for all origins to simplify development. You can change this behavior by setting the `ENVIRONMENT` environment variable to `prod`:
+To start the app optimized for **production**, run:
 
 ```
-ENVIRONMENT=prod poetry run python main.py
+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:

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

@@ -1,16 +1,7 @@
-import os
 from typing import Any, Dict, List, Optional
 
-from app.engine.index import IndexConfig, get_index
-from app.engine.tools import ToolFactory
-from app.workflows.events import AgentRunEvent
-from app.workflows.tools import (
-    call_tools,
-    chat_with_tools,
-)
 from llama_index.core import Settings
 from llama_index.core.base.llms.types import ChatMessage, MessageRole
-from llama_index.core.indices.vector_store import VectorStoreIndex
 from llama_index.core.llms.function_calling import FunctionCallingLLM
 from llama_index.core.memory import ChatMemoryBuffer
 from llama_index.core.tools import FunctionTool, QueryEngineTool, ToolSelection
@@ -23,20 +14,28 @@ from llama_index.core.workflow import (
     step,
 )
 
+from app.engine.index import IndexConfig, get_index
+from app.engine.tools import ToolFactory
+from app.engine.tools.query_engine import get_query_engine_tool
+from app.workflows.events import AgentRunEvent
+from app.workflows.tools import (
+    call_tools,
+    chat_with_tools,
+)
+
 
 def create_workflow(
-    chat_history: Optional[List[ChatMessage]] = None,
     params: Optional[Dict[str, Any]] = None,
-    filters: Optional[List[Any]] = None,
+    **kwargs,
 ) -> Workflow:
+    # Create query engine tool
     index_config = IndexConfig(**params)
-    index: VectorStoreIndex = get_index(config=index_config)
+    index = get_index(index_config)
     if index is None:
-        query_engine_tool = None
-    else:
-        top_k = int(os.getenv("TOP_K", 10))
-        query_engine = index.as_query_engine(similarity_top_k=top_k, filters=filters)
-        query_engine_tool = QueryEngineTool.from_defaults(query_engine=query_engine)
+        raise ValueError(
+            "Index is not found. Try run generation script to create the index first."
+        )
+    query_engine_tool = get_query_engine_tool(index=index)
 
     configured_tools: Dict[str, FunctionTool] = ToolFactory.from_env(map_result=True)  # type: ignore
     code_interpreter_tool = configured_tools.get("interpret")
@@ -46,7 +45,6 @@ def create_workflow(
         query_engine_tool=query_engine_tool,
         code_interpreter_tool=code_interpreter_tool,
         document_generator_tool=document_generator_tool,
-        chat_history=chat_history,
     )
 
 
@@ -92,6 +90,7 @@ class FinancialReportWorkflow(Workflow):
     It's good to using appropriate tools for the user request and always use the information from the tools, don't make up anything yourself.
     For the query engine tool, you should break down the user request into a list of queries and call the tool with the queries.
     """
+    stream: bool = True
 
     def __init__(
         self,
@@ -100,22 +99,20 @@ class FinancialReportWorkflow(Workflow):
         document_generator_tool: FunctionTool,
         llm: Optional[FunctionCallingLLM] = None,
         timeout: int = 360,
-        chat_history: Optional[List[ChatMessage]] = None,
         system_prompt: Optional[str] = None,
     ):
         super().__init__(timeout=timeout)
         self.system_prompt = system_prompt or self._default_system_prompt
-        self.chat_history = chat_history or []
         self.query_engine_tool = query_engine_tool
         self.code_interpreter_tool = code_interpreter_tool
         self.document_generator_tool = document_generator_tool
-        assert (
-            query_engine_tool is not None
-        ), "Query engine tool is not found. Try run generation script or upload a document file first."
+        assert query_engine_tool is not None, (
+            "Query engine tool is not found. Try run generation script or upload a document file first."
+        )
         assert code_interpreter_tool is not None, "Code interpreter tool is required"
-        assert (
-            document_generator_tool is not None
-        ), "Document generator tool is required"
+        assert document_generator_tool is not None, (
+            "Document generator tool is required"
+        )
         self.tools = [
             self.query_engine_tool,
             self.code_interpreter_tool,
@@ -123,13 +120,19 @@ class FinancialReportWorkflow(Workflow):
         ]
         self.llm: FunctionCallingLLM = llm or Settings.llm
         assert isinstance(self.llm, FunctionCallingLLM)
-        self.memory = ChatMemoryBuffer.from_defaults(
-            llm=self.llm, chat_history=self.chat_history
-        )
+        self.memory = ChatMemoryBuffer.from_defaults(llm=self.llm)
 
     @step()
     async def prepare_chat_history(self, ctx: Context, ev: StartEvent) -> InputEvent:
-        ctx.data["input"] = ev.input
+        self.stream = ev.get("stream", True)
+        user_msg = ev.get("user_msg")
+        chat_history = ev.get("chat_history")
+
+        if chat_history is not None:
+            self.memory.put_messages(chat_history)
+
+        # Add user message to memory
+        self.memory.put(ChatMessage(role=MessageRole.USER, content=user_msg))
 
         if self.system_prompt:
             system_msg = ChatMessage(
@@ -137,9 +140,6 @@ class FinancialReportWorkflow(Workflow):
             )
             self.memory.put(system_msg)
 
-        # Add user input to memory
-        self.memory.put(ChatMessage(role=MessageRole.USER, content=ev.input))
-
         return InputEvent(input=self.memory.get())
 
     @step()
@@ -161,8 +161,10 @@ class FinancialReportWorkflow(Workflow):
             chat_history,
         )
         if not response.has_tool_calls():
-            # If no tool call, return the response generator
-            return StopEvent(result=response.generator)
+            if self.stream:
+                return StopEvent(result=response.generator)
+            else:
+                return StopEvent(result=await response.full_response())
         # calling different tools at the same time is not supported at the moment
         # add an error message to tell the AI to process step by step
         if response.is_calling_different_tools():

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

@@ -7,7 +7,7 @@ First, setup the environment with poetry:
 > **_Note:_** This step is not needed if you are using the dev-container.
 
 ```shell
-poetry install
+uv sync
 ```
 
 Then check the parameters that have been pre-configured in the `.env` file in this directory.
@@ -16,7 +16,7 @@ Make sure you have the `OPENAI_API_KEY` set.
 Second, run the development server:
 
 ```shell
-poetry run python main.py
+uv run dev
 ```
 
 ## Use Case: Filling Financial CSV Template
@@ -41,14 +41,18 @@ curl --location 'localhost:8000/api/chat' \
 
 You can start editing the API by modifying `app/api/routers/chat.py` or `app/workflows/form_filling.py`. The API auto-updates as you save the files.
 
-Open [http://localhost:8000/docs](http://localhost:8000/docs) with your browser to see the Swagger UI of the API.
+Open [http://localhost:8000](http://localhost:8000) with your browser to start the app.
 
-The API allows CORS for all origins to simplify development. You can change this behavior by setting the `ENVIRONMENT` environment variable to `prod`:
+To start the app optimized for **production**, run:
 
 ```
-ENVIRONMENT=prod poetry run python main.py
+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:

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

@@ -1,16 +1,7 @@
-import os
 from typing import Any, Dict, List, Optional
 
-from app.engine.index import IndexConfig, get_index
-from app.engine.tools import ToolFactory
-from app.workflows.events import AgentRunEvent
-from app.workflows.tools import (
-    call_tools,
-    chat_with_tools,
-)
 from llama_index.core import Settings
 from llama_index.core.base.llms.types import ChatMessage, MessageRole
-from llama_index.core.indices.vector_store import VectorStoreIndex
 from llama_index.core.llms.function_calling import FunctionCallingLLM
 from llama_index.core.memory import ChatMemoryBuffer
 from llama_index.core.tools import FunctionTool, QueryEngineTool, ToolSelection
@@ -23,24 +14,27 @@ from llama_index.core.workflow import (
     step,
 )
 
+from app.engine.index import IndexConfig, get_index
+from app.engine.tools import ToolFactory
+from app.engine.tools.query_engine import get_query_engine_tool
+from app.workflows.events import AgentRunEvent
+from app.workflows.tools import (
+    call_tools,
+    chat_with_tools,
+)
+
 
 def create_workflow(
-    chat_history: Optional[List[ChatMessage]] = None,
     params: Optional[Dict[str, Any]] = None,
-    filters: Optional[List[Any]] = None,
+    **kwargs,
 ) -> Workflow:
-    if params is None:
-        params = {}
-    if filters is None:
-        filters = []
+    # Create query engine tool
     index_config = IndexConfig(**params)
-    index: VectorStoreIndex = get_index(config=index_config)
+    index = get_index(index_config)
     if index is None:
         query_engine_tool = None
     else:
-        top_k = int(os.getenv("TOP_K", 10))
-        query_engine = index.as_query_engine(similarity_top_k=top_k, filters=filters)
-        query_engine_tool = QueryEngineTool.from_defaults(query_engine=query_engine)
+        query_engine_tool = get_query_engine_tool(index=index)
 
     configured_tools = ToolFactory.from_env(map_result=True)
     extractor_tool = configured_tools.get("extract_questions")  # type: ignore
@@ -50,7 +44,6 @@ def create_workflow(
         query_engine_tool=query_engine_tool,
         extractor_tool=extractor_tool,  # type: ignore
         filling_tool=filling_tool,  # type: ignore
-        chat_history=chat_history,
     )
 
     return workflow
@@ -93,6 +86,7 @@ class FormFillingWorkflow(Workflow):
     Only use provided data - never make up any information yourself. Fill N/A if an answer is not found.
     If there is no query engine tool or the gathered information has many N/A values indicating the questions don't match the data, respond with a warning and ask the user to upload a different file or connect to a knowledge base.
     """
+    stream: bool = True
 
     def __init__(
         self,
@@ -101,12 +95,10 @@ class FormFillingWorkflow(Workflow):
         filling_tool: FunctionTool,
         llm: Optional[FunctionCallingLLM] = None,
         timeout: int = 360,
-        chat_history: Optional[List[ChatMessage]] = None,
         system_prompt: Optional[str] = None,
     ):
         super().__init__(timeout=timeout)
         self.system_prompt = system_prompt or self._default_system_prompt
-        self.chat_history = chat_history or []
         self.query_engine_tool = query_engine_tool
         self.extractor_tool = extractor_tool
         self.filling_tool = filling_tool
@@ -118,13 +110,18 @@ class FormFillingWorkflow(Workflow):
         self.llm: FunctionCallingLLM = llm or Settings.llm
         if not isinstance(self.llm, FunctionCallingLLM):
             raise ValueError("FormFillingWorkflow only supports FunctionCallingLLM.")
-        self.memory = ChatMemoryBuffer.from_defaults(
-            llm=self.llm, chat_history=self.chat_history
-        )
+        self.memory = ChatMemoryBuffer.from_defaults(llm=self.llm)
 
     @step()
     async def start(self, ctx: Context, ev: StartEvent) -> InputEvent:
-        ctx.data["input"] = ev.input
+        self.stream = ev.get("stream", True)
+        user_msg = ev.get("user_msg", "")
+        chat_history = ev.get("chat_history", [])
+
+        if chat_history:
+            self.memory.put_messages(chat_history)
+
+        self.memory.put(ChatMessage(role=MessageRole.USER, content=user_msg))
 
         if self.system_prompt:
             system_msg = ChatMessage(
@@ -132,12 +129,7 @@ class FormFillingWorkflow(Workflow):
             )
             self.memory.put(system_msg)
 
-        user_input = ev.input
-        user_msg = ChatMessage(role=MessageRole.USER, content=user_input)
-        self.memory.put(user_msg)
-
-        chat_history = self.memory.get()
-        return InputEvent(input=chat_history)
+        return InputEvent(input=self.memory.get())
 
     @step()
     async def handle_llm_input(  # type: ignore
@@ -155,7 +147,10 @@ class FormFillingWorkflow(Workflow):
             chat_history,
         )
         if not response.has_tool_calls():
-            return StopEvent(result=response.generator)
+            if self.stream:
+                return StopEvent(result=response.generator)
+            else:
+                return StopEvent(result=await response.full_response())
         # calling different tools at the same time is not supported at the moment
         # add an error message to tell the AI to process step by step
         if response.is_calling_different_tools():

packages/create-llama/templates/components/agents/typescript/blog/workflow/agents.ts

@@ -1,15 +1,15 @@
 import { ChatMessage } from "llamaindex";
 import { getTool } from "../engine/tools";
 import { FunctionCallingAgent } from "./single-agent";
-import { getQueryEngineTools } from "./tools";
+import { getQueryEngineTool } from "./tools";
 
 export const createResearcher = async (chatHistory: ChatMessage[]) => {
-  const queryEngineTools = await getQueryEngineTools();
+  const queryEngineTool = await getQueryEngineTool();
   const tools = [
     await getTool("wikipedia_tool"),
     await getTool("duckduckgo_search"),
     await getTool("image_generator"),
-    ...(queryEngineTools ? queryEngineTools : []),
+    queryEngineTool,
   ].filter((tool) => tool !== undefined);
 
   return new FunctionCallingAgent({