unify tool name

.changeset/cool-cars-promise.md

@@ -0,0 +1,5 @@
+---
+"create-llama": patch
+---
+
+Migrate AgentRunner to Agent Workflow (Python)

.changeset/mean-fireants-visit.md

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

.changeset/rare-eyes-protect.md

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

.eslintrc

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

.github/workflows/e2e.yml

@@ -1,15 +1,12 @@
-name: E2E Tests for create-llama package
+name: E2E Tests
 on:
   push:
     branches: [main]
-    paths-ignore:
-      - "python/llama-index-server/**"
-      - ".github/workflows/*llama_index_server.yml"
   pull_request:
     branches: [main]
-    paths-ignore:
-      - "python/llama-index-server/**"
-      - ".github/workflows/*llama_index_server.yml"
+
+env:
+  POETRY_VERSION: "1.6.1"
 
 jobs:
   e2e-python:
@@ -22,8 +19,7 @@ jobs:
         python-version: ["3.11"]
         os: [macos-latest, windows-latest, ubuntu-22.04]
         frameworks: ["fastapi"]
-        datasources: ["--no-files", "--example-file", "--llamacloud"]
-        template-types: ["streaming", "llamaindexserver"]
+        datasources: ["--example-file", "--llamacloud"]
     defaults:
       run:
         shell: bash
@@ -36,10 +32,10 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
-      - name: Install uv
-        run: curl -LsSf https://astral.sh/uv/install.sh | sh
-      - name: Add uv to PATH # Ensure uv is available in subsequent steps
-        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+      - name: Install Poetry
+        uses: snok/install-poetry@v1
+        with:
+          version: ${{ env.POETRY_VERSION }}
 
       - uses: pnpm/action-setup@v3
 
@@ -54,15 +50,15 @@ jobs:
 
       - name: Install Playwright Browsers
         run: pnpm exec playwright install --with-deps
-        working-directory: packages/create-llama
+        working-directory: .
 
       - name: Build create-llama
         run: pnpm run build
-        working-directory: packages/create-llama
+        working-directory: .
 
       - name: Install
         run: pnpm run pack-install
-        working-directory: packages/create-llama
+        working-directory: .
 
       - name: Run Playwright tests for Python
         run: pnpm run e2e:python
@@ -71,16 +67,13 @@ jobs:
           LLAMA_CLOUD_API_KEY: ${{ secrets.LLAMA_CLOUD_API_KEY }}
           FRAMEWORK: ${{ matrix.frameworks }}
           DATASOURCE: ${{ matrix.datasources }}
-          TEMPLATE_TYPE: ${{ matrix.template-types }}
-          PYTHONIOENCODING: utf-8
-          PYTHONLEGACYWINDOWSSTDIO: utf-8
-        working-directory: packages/create-llama
+        working-directory: .
 
       - uses: actions/upload-artifact@v4
         if: always()
         with:
-          name: playwright-report-python-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.datasources }}-${{ matrix.template-types }}
-          path: packages/create-llama/playwright-report/
+          name: playwright-report-python-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.datasources }}
+          path: ./playwright-report/
           overwrite: true
           retention-days: 30
 
@@ -90,12 +83,11 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        node-version: [20, 22]
+        node-version: [18, 20]
         python-version: ["3.11"]
         os: [macos-latest, windows-latest, ubuntu-22.04]
-        frameworks: ["nextjs"]
+        frameworks: ["nextjs", "express"]
         datasources: ["--no-files", "--example-file", "--llamacloud"]
-        template-types: ["streaming", "llamaindexserver"]
     defaults:
       run:
         shell: bash
@@ -108,10 +100,10 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
-      - name: Install uv
-        run: curl -LsSf https://astral.sh/uv/install.sh | sh
-      - name: Add uv to PATH # Ensure uv is available in subsequent steps
-        run: echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+      - name: Install Poetry
+        uses: snok/install-poetry@v1
+        with:
+          version: ${{ env.POETRY_VERSION }}
 
       - uses: pnpm/action-setup@v3
 
@@ -126,30 +118,15 @@ jobs:
 
       - name: Install Playwright Browsers
         run: pnpm exec playwright install --with-deps
-        working-directory: packages/create-llama
+        working-directory: .
 
       - name: Build create-llama
         run: pnpm run build
-        working-directory: packages/create-llama
+        working-directory: .
 
       - name: Install
         run: pnpm run pack-install
-        working-directory: packages/create-llama
-
-      - name: Build server
-        run: pnpm run build
-        working-directory: packages/server
-
-      - name: Pack @llamaindex/server package
-        run: |
-          pnpm pack --pack-destination "${{ runner.temp }}"
-          if [ "${{ runner.os }}" == "Windows" ]; then
-            file=$(find "${{ runner.temp }}" -name "llamaindex-server-*.tgz" | head -n 1)
-            mv "$file" "${{ runner.temp }}/llamaindex-server.tgz"
-          else
-            mv ${{ runner.temp }}/llamaindex-server-*.tgz ${{ runner.temp }}/llamaindex-server.tgz
-          fi
-        working-directory: packages/server
+        working-directory: .
 
       - name: Run Playwright tests for TypeScript
         run: pnpm run e2e:typescript
@@ -158,14 +135,12 @@ jobs:
           LLAMA_CLOUD_API_KEY: ${{ secrets.LLAMA_CLOUD_API_KEY }}
           FRAMEWORK: ${{ matrix.frameworks }}
           DATASOURCE: ${{ matrix.datasources }}
-          TEMPLATE_TYPE: ${{ matrix.template-types }}
-          SERVER_PACKAGE_PATH: ${{ runner.temp }}/llamaindex-server.tgz
-        working-directory: packages/create-llama
+        working-directory: .
 
       - uses: actions/upload-artifact@v4
         if: always()
         with:
-          name: playwright-report-typescript-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.datasources }}-node${{ matrix.node-version }}-${{ matrix.template-types }}
-          path: packages/create-llama/playwright-report/
+          name: playwright-report-typescript-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.datasources }}-node${{ matrix.node-version }}
+          path: ./playwright-report/
           overwrite: true
           retention-days: 30

.github/workflows/lint_on_push_or_pull.yml

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

.github/workflows/release_llama_index_server.yml

@@ -1,138 +0,0 @@
-name: Release llama-index-server
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - "python/llama-index-server/**"
-      - ".github/workflows/release_llama_index_server.yml"
-  pull_request:
-    types:
-      - closed
-
-concurrency: ${{ github.workflow }}-${{ github.ref }}
-
-jobs:
-  release:
-    name: Create Release PR
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./python/llama-index-server
-    if: |
-      github.event_name == 'push' && 
-      !startsWith(github.ref, 'refs/heads/release/llama-index-server-v') &&
-      !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

@@ -1,99 +0,0 @@
-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,6 +6,9 @@ node_modules
 .pnpm-store
 .pnp.js
 
+# testing
+coverage
+
 # next.js
 .next/
 out/
@@ -31,9 +34,24 @@ 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,4 +1,3 @@
 pnpm format
 pnpm lint
-uvx ruff check .
-uvx ruff format . --check 
+uvx ruff format --check templates/

.prettierignore

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

CHANGELOG.md

@@ -1,121 +1,5 @@
 # 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

README.md

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

create-app.ts

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

e2e/python/resolve_dependencies.spec.ts

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

e2e/shared/multiagent_template.spec.ts

@@ -1,3 +1,4 @@
+/* eslint-disable turbo/no-undeclared-env-vars */
 import { expect, test } from "@playwright/test";
 import { ChildProcess } from "child_process";
 import fs from "fs";
@@ -12,30 +13,19 @@ import { createTestDir, runCreateLlama, type AppType } from "../utils";
 const templateFramework: TemplateFramework = process.env.FRAMEWORK
   ? (process.env.FRAMEWORK as TemplateFramework)
   : "fastapi";
-const dataSource: string = process.env.DATASOURCE
-  ? (process.env.DATASOURCE as string)
-  : "--example-file";
-const llamaCloudProjectName = "create-llama";
-const llamaCloudIndexName = "e2e-test";
-
+const dataSource: string = "--example-file";
 const templateUI: TemplateUI = "shadcn";
 const templatePostInstallAction: TemplatePostInstallAction = "runApp";
-const appType: AppType = "--frontend";
+const appType: AppType = templateFramework === "fastapi" ? "--frontend" : "";
 const userMessage = "Write a blog post about physical standards for letters";
-const templateUseCases = [
-  "agentic_rag",
-  "financial_report",
-  "deep_research",
-  "code_generator",
-];
+const templateUseCases = ["financial_report", "blog", "form_filling"];
 
 for (const useCase of templateUseCases) {
-  test.describe(`Test use case ${useCase} ${templateFramework} ${dataSource} ${templateUI} ${appType} ${templatePostInstallAction}`, async () => {
+  test.describe(`Test multiagent template ${useCase} ${templateFramework} ${dataSource} ${templateUI} ${appType} ${templatePostInstallAction}`, async () => {
     test.skip(
-      dataSource === "--no-files" || templateFramework === "express",
-      "The llamaindexserver template currently only works with nextjs, fastapi. We also only run on Linux to speed up tests.",
+      process.platform !== "linux" || process.env.DATASOURCE === "--no-files",
+      "The multiagent template currently only works with files. We also only run on Linux to speed up tests.",
     );
-    const useLlamaParse = dataSource === "--llamacloud";
     let port: number;
     let cwd: string;
     let name: string;
@@ -48,7 +38,7 @@ for (const useCase of templateUseCases) {
       cwd = await createTestDir();
       const result = await runCreateLlama({
         cwd,
-        templateType: "llamaindexserver",
+        templateType: "multiagent",
         templateFramework,
         dataSource,
         vectorDb,
@@ -57,9 +47,6 @@ for (const useCase of templateUseCases) {
         templateUI,
         appType,
         useCase,
-        llamaCloudProjectName,
-        llamaCloudIndexName,
-        useLlamaParse,
       });
       name = result.projectName;
       appProcess = result.appProcess;
@@ -76,9 +63,7 @@ for (const useCase of templateUseCases) {
           templateFramework === "express",
       );
       await page.goto(`http://localhost:${port}`);
-      await expect(page.getByText("Built by LlamaIndex")).toBeVisible({
-        timeout: 5 * 60 * 1000,
-      });
+      await expect(page.getByText("Built by LlamaIndex")).toBeVisible();
     });
 
     test("Frontend should be able to submit a message and receive the start of a streamed response", async ({
@@ -87,9 +72,9 @@ for (const useCase of templateUseCases) {
       test.skip(
         templatePostInstallAction !== "runApp" ||
           useCase === "financial_report" ||
-          useCase === "deep_research" ||
+          useCase === "form_filling" ||
           templateFramework === "express",
-        "Skip chat tests for financial report and deep research.",
+        "Skip chat tests for financial report and form filling.",
       );
       await page.goto(`http://localhost:${port}`);
       await page.fill("form textarea", userMessage);
@@ -101,12 +86,6 @@ for (const useCase of templateUseCases) {
       await page.click("form button[type=submit]");
 
       const response = await responsePromise;
-      console.log(`Response status: ${response.status()}`);
-      const responseBody = await response
-        .text()
-        .catch((e) => `Error reading body: ${e}`);
-      console.log(`Response body: ${responseBody}`);
-
       expect(response.ok()).toBeTruthy();
     });
 

e2e/shared/reflex_template.spec.ts

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

e2e/shared/streaming_template.spec.ts

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

e2e/typescript/resolve_dependencies.spec.ts

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

e2e/utils.ts

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

eslint.config.mjs

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

helpers/copy.ts

@@ -1,3 +1,4 @@
+/* eslint-disable import/no-extraneous-dependencies */
 import { async as glob } from "fast-glob";
 import fs from "fs";
 import path from "path";

helpers/env-variables.ts

@@ -44,7 +44,6 @@ const renderEnvVar = (envVars: EnvVar[]): string => {
 const getVectorDBEnvs = (
   vectorDb?: TemplateVectorDB,
   framework?: TemplateFramework,
-  template?: TemplateType,
 ): EnvVar[] => {
   if (!vectorDb || !framework) {
     return [];
@@ -169,7 +168,7 @@ const getVectorDBEnvs = (
           description:
             "The organization ID for the LlamaCloud project (uses default organization if not specified)",
         },
-        ...(framework === "nextjs" && template !== "llamaindexserver"
+        ...(framework === "nextjs"
           ? // activate index selector per default (not needed for non-NextJS backends as it's handled by createFrontendEnvFile)
             [
               {
@@ -181,7 +180,7 @@ const getVectorDBEnvs = (
             ]
           : []),
       ];
-    case "chroma": {
+    case "chroma":
       const envs = [
         {
           name: "CHROMA_COLLECTION",
@@ -206,7 +205,6 @@ Otherwise, use CHROMA_HOST and CHROMA_PORT config above`,
         });
       }
       return envs;
-    }
     case "weaviate":
       return [
         {
@@ -225,15 +223,13 @@ Otherwise, use CHROMA_HOST and CHROMA_PORT config above`,
         },
       ];
     default:
-      return template !== "llamaindexserver"
-        ? [
-            {
-              name: "STORAGE_CACHE_DIR",
-              description: "The directory to store the local storage cache.",
-              value: ".cache",
-            },
-          ]
-        : [];
+      return [
+        {
+          name: "STORAGE_CACHE_DIR",
+          description: "The directory to store the local storage cache.",
+          value: ".cache",
+        },
+      ];
   }
 };
 
@@ -386,42 +382,38 @@ const getModelEnvs = (modelConfig: ModelConfig): EnvVar[] => {
 
 const getFrameworkEnvs = (
   framework: TemplateFramework,
-  template: TemplateType,
   port?: number,
 ): EnvVar[] => {
   const sPort = port?.toString() || "8000";
-  const result: EnvVar[] =
-    template !== "llamaindexserver"
-      ? [
-          {
-            name: "FILESERVER_URL_PREFIX",
-            description:
-              "FILESERVER_URL_PREFIX is the URL prefix of the server storing the images generated by the interpreter.",
-            value:
-              framework === "nextjs"
-                ? // FIXME: if we are using nextjs, port should be 3000
-                  "http://localhost:3000/api/files"
-                : `http://localhost:${sPort}/api/files`,
-          },
-        ]
-      : [];
+  const result: EnvVar[] = [
+    {
+      name: "FILESERVER_URL_PREFIX",
+      description:
+        "FILESERVER_URL_PREFIX is the URL prefix of the server storing the images generated by the interpreter.",
+      value:
+        framework === "nextjs"
+          ? // FIXME: if we are using nextjs, port should be 3000
+            "http://localhost:3000/api/files"
+          : `http://localhost:${sPort}/api/files`,
+    },
+  ];
   if (framework === "fastapi") {
     result.push(
       ...[
         {
           name: "APP_HOST",
-          description: "The address to start the FastAPI app.",
+          description: "The address to start the backend app.",
           value: "0.0.0.0",
         },
         {
           name: "APP_PORT",
-          description: "The port to start the FastAPI app.",
+          description: "The port to start the backend app.",
           value: sPort,
         },
       ],
     );
   }
-  if (framework === "nextjs" && template !== "llamaindexserver") {
+  if (framework === "nextjs") {
     result.push({
       name: "NEXT_PUBLIC_CHAT_API",
       description:
@@ -491,11 +483,12 @@ const getSystemPromptEnv = (
     });
   }
   if (tools?.length == 0 && (dataSources?.length ?? 0 > 0)) {
-    const citationPrompt = `'You have provided information from a knowledge base that has been passed to you in nodes of information.
-Each node has useful metadata such as node ID, file name, page, etc.
-Please add the citation to the data node for each sentence or paragraph that you reference in the provided information.
-The citation format is: . [citation:<node_id>]()
-Where the <node_id> is the unique identifier of the data node.
+    const citationPrompt = `'You have provided information from a knowledge base that separates the information into multiple nodes.
+Always add a citation to each sentence or paragraph that you reference in the provided information using the node_id field in the header of each node.
+
+The citation format is: [citation:<node_id>]
+Where the <node_id> is the node_id field in the header of each node.
+Always separate the citation by a space.
 
 Example:
 We have two nodes:
@@ -505,11 +498,9 @@ We have two nodes:
   node_id: abc
   file_name: animal.pdf
 
-User question: Tell me a fun fact about Llama.
-Your answer:
-A baby llama is called "Cria" [citation:xyz]().
-It often live in desert [citation:abc]().
-It\\'s cute animal.
+Your answer with citations:
+A baby llama is called "Cria" [citation:xyz]
+It often lives in desert [citation:abc] [citation:xyz]
 '`;
     systemPromptEnv.push({
       name: "SYSTEM_CITATION_PROMPT",
@@ -577,41 +568,25 @@ export const createBackendEnvFile = async (
     | "port"
     | "tools"
     | "observability"
-    | "useLlamaParse"
   >,
 ) => {
   // Init env values
   const envFileName = ".env";
   const envVars: EnvVar[] = [
-    ...(opts.useLlamaParse
-      ? [
-          {
-            name: "LLAMA_CLOUD_API_KEY",
-            description: `The Llama Cloud API key.`,
-            value: opts.llamaCloudKey,
-          },
-        ]
-      : []),
-    ...getVectorDBEnvs(opts.vectorDb, opts.framework, opts.template),
-    ...getToolEnvs(opts.tools),
-    ...getFrameworkEnvs(opts.framework, opts.template, opts.port),
+    {
+      name: "LLAMA_CLOUD_API_KEY",
+      description: `The Llama Cloud API key.`,
+      value: opts.llamaCloudKey,
+    },
     // Add environment variables of each component
-    ...(opts.template === "llamaindexserver"
-      ? [
-          {
-            name: "OPENAI_API_KEY",
-            description: "The OpenAI API key to use.",
-            value: opts.modelConfig.apiKey,
-          },
-        ]
-      : [
-          // don't use this stuff for llama-indexserver
-          ...getModelEnvs(opts.modelConfig),
-          ...getEngineEnvs(),
-          ...getTemplateEnvs(opts.template),
-          ...getObservabilityEnvs(opts.observability),
-          ...getSystemPromptEnv(opts.tools, opts.dataSources, opts.template),
-        ]),
+    ...getModelEnvs(opts.modelConfig),
+    ...getEngineEnvs(),
+    ...getVectorDBEnvs(opts.vectorDb, opts.framework),
+    ...getFrameworkEnvs(opts.framework, opts.port),
+    ...getToolEnvs(opts.tools),
+    ...getTemplateEnvs(opts.template),
+    ...getObservabilityEnvs(opts.observability),
+    ...getSystemPromptEnv(opts.tools, opts.dataSources, opts.template),
   ];
   // Render and write env file
   const content = renderEnvVar(envVars);

helpers/git.ts

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

helpers/index.ts

@@ -1,7 +1,7 @@
 import { callPackageManager } from "./install";
 
 import path from "path";
-import picocolors, { cyan } from "picocolors";
+import { cyan } from "picocolors";
 
 import fsExtra from "fs-extra";
 import { writeLoadersConfig } from "./datasources";
@@ -9,6 +9,7 @@ import { createBackendEnvFile, createFrontendEnvFile } from "./env-variables";
 import { PackageManager } from "./get-pkg-manager";
 import { installLlamapackProject } from "./llama-pack";
 import { makeDir } from "./make-dir";
+import { isHavingPoetryLockFile, tryPoetryRun } from "./poetry";
 import { installPythonTemplate } from "./python";
 import { downloadAndExtractRepo } from "./repo";
 import { ConfigFileType, writeToolsConfig } from "./tools";
@@ -18,11 +19,9 @@ import {
   ModelConfig,
   TemplateDataSource,
   TemplateFramework,
-  TemplateUseCase,
   TemplateVectorDB,
 } from "./types";
 import { installTSTemplate } from "./typescript";
-import { isHavingUvLockFile, tryUvRun } from "./uv";
 
 const checkForGenerateScript = (
   modelConfig: ModelConfig,
@@ -42,11 +41,7 @@ const checkForGenerateScript = (
     missingSettings.push("your LLAMA_CLOUD_API_KEY");
   }
 
-  if (
-    vectorDb !== undefined &&
-    vectorDb !== "none" &&
-    vectorDb !== "llamacloud"
-  ) {
+  if (vectorDb !== "none" && vectorDb !== "llamacloud") {
     missingSettings.push("your Vector DB environment variables");
   }
 
@@ -61,12 +56,11 @@ async function generateContextData(
   vectorDb?: TemplateVectorDB,
   llamaCloudKey?: string,
   useLlamaParse?: boolean,
-  useCase?: TemplateUseCase,
 ) {
   if (packageManager) {
     const runGenerate = `${cyan(
       framework === "fastapi"
-        ? "uv run generate"
+        ? "poetry run generate"
         : `${packageManager} run generate`,
     )}`;
 
@@ -80,43 +74,32 @@ async function generateContextData(
     if (!missingSettings.length) {
       // If all the required environment variables are set, run the generate script
       if (framework === "fastapi") {
-        if (isHavingUvLockFile()) {
+        if (isHavingPoetryLockFile()) {
           console.log(`Running ${runGenerate} to generate the context data.`);
-          const result = tryUvRun("generate");
+          const result = tryPoetryRun("poetry run generate");
           if (!result) {
             console.log(`Failed to run ${runGenerate}.`);
             process.exit(1);
           }
           console.log(`Generated context data`);
           return;
-        } else {
-          console.log(
-            picocolors.yellow(
-              `\nWarning: uv.lock not found. Dependency installation might be incomplete. Skipping context generation.\nIf dependencies were installed, try running '${runGenerate}' manually.\n`,
-            ),
-          );
         }
       } else {
         console.log(`Running ${runGenerate} to generate the context data.`);
-        const shouldRunGenerate =
-          useCase !== "code_generator" && useCase !== "document_generator"; // Artifact use case doesn't use index.
-
-        if (shouldRunGenerate) {
-          await callPackageManager(packageManager, true, ["run", "generate"]);
-        }
+        await callPackageManager(packageManager, true, ["run", "generate"]);
         return;
       }
     }
 
     const settingsMessage = `After setting ${missingSettings.join(" and ")}, run ${runGenerate} to generate the context data.`;
-    console.log(picocolors.yellow(`\n${settingsMessage}\n\n`));
+    console.log(`\n${settingsMessage}\n\n`);
   }
 }
 
 const downloadFile = async (url: string, destPath: string) => {
   const response = await fetch(url);
   const fileBuffer = await response.arrayBuffer();
-  await fsExtra.writeFile(destPath, new Uint8Array(fileBuffer));
+  await fsExtra.writeFile(destPath, Buffer.from(fileBuffer));
 };
 
 const prepareContextData = async (
@@ -183,17 +166,6 @@ export const installTemplate = async (
 
   if (props.framework === "fastapi") {
     await installPythonTemplate(props);
-  } else {
-    await installTSTemplate(props);
-  }
-
-  // write configurations
-  if (props.template !== "llamaindexserver") {
-    await writeToolsConfig(
-      props.root,
-      props.tools,
-      props.framework === "fastapi" ? ConfigFileType.YAML : ConfigFileType.JSON,
-    );
     if (props.vectorDb !== "llamacloud") {
       // write loaders configuration (currently Python only)
       // not needed for LlamaCloud as it has its own loaders
@@ -203,13 +175,26 @@ export const installTemplate = async (
         props.useLlamaParse,
       );
     }
+  } else {
+    await installTSTemplate(props);
   }
 
+  // write tools configuration
+  await writeToolsConfig(
+    props.root,
+    props.tools,
+    props.framework === "fastapi" ? ConfigFileType.YAML : ConfigFileType.JSON,
+  );
+
   if (props.backend) {
     // This is a backend, so we need to copy the test data and create the env file.
 
     // Copy the environment file to the target directory.
-    if (props.template !== "community" && props.template !== "llamapack") {
+    if (
+      props.template === "streaming" ||
+      props.template === "multiagent" ||
+      props.template === "reflex"
+    ) {
       await createBackendEnvFile(props.root, props);
     }
 
@@ -231,7 +216,6 @@ export const installTemplate = async (
         props.vectorDb,
         props.llamaCloudKey,
         props.useLlamaParse,
-        props.useCase,
       );
     }
 

helpers/install.ts

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

helpers/is-folder-empty.ts

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

helpers/llama-pack.ts

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

helpers/poetry.ts

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

helpers/providers/index.ts

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

helpers/python.ts

@@ -3,16 +3,15 @@ import path from "path";
 import { cyan, red } from "picocolors";
 import { parse, stringify } from "smol-toml";
 import terminalLink from "terminal-link";
-import { isUvAvailable, tryUvSync } from "./uv";
 
 import { 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";
@@ -30,8 +29,6 @@ const getAdditionalDependencies = (
   dataSources?: TemplateDataSource[],
   tools?: Tool[],
   templateType?: TemplateType,
-  observability?: TemplateObservability,
-  // eslint-disable-next-line max-params
 ) => {
   const dependencies: Dependency[] = [];
 
@@ -40,21 +37,21 @@ const getAdditionalDependencies = (
     case "mongo": {
       dependencies.push({
         name: "llama-index-vector-stores-mongodb",
-        version: ">=0.3.2,<0.4.0",
+        version: "^0.6.0",
       });
       break;
     }
     case "pg": {
       dependencies.push({
         name: "llama-index-vector-stores-postgres",
-        version: ">=0.3.2,<0.4.0",
+        version: "^0.3.2",
       });
       break;
     }
     case "pinecone": {
       dependencies.push({
         name: "llama-index-vector-stores-pinecone",
-        version: ">=0.4.1,<0.5.0",
+        version: "^0.4.1",
         constraints: {
           python: ">=3.11,<3.13",
         },
@@ -64,25 +61,25 @@ const getAdditionalDependencies = (
     case "milvus": {
       dependencies.push({
         name: "llama-index-vector-stores-milvus",
-        version: ">=0.3.0,<0.4.0",
+        version: "^0.3.0",
       });
       dependencies.push({
         name: "pymilvus",
-        version: ">=2.4.4,<3.0.0",
+        version: "2.4.4",
       });
       break;
     }
     case "astra": {
       dependencies.push({
         name: "llama-index-vector-stores-astra-db",
-        version: ">=0.4.0,<0.5.0",
+        version: "^0.4.0",
       });
       break;
     }
     case "qdrant": {
       dependencies.push({
         name: "llama-index-vector-stores-qdrant",
-        version: ">=0.4.0,<0.5.0",
+        version: "^0.4.0",
         constraints: {
           python: ">=3.11,<3.13",
         },
@@ -92,25 +89,21 @@ const getAdditionalDependencies = (
     case "chroma": {
       dependencies.push({
         name: "llama-index-vector-stores-chroma",
-        version: ">=0.4.0,<0.5.0",
-      });
-      dependencies.push({
-        name: "onnxruntime",
-        version: "<1.22.0",
+        version: "^0.4.0",
       });
       break;
     }
     case "weaviate": {
       dependencies.push({
         name: "llama-index-vector-stores-weaviate",
-        version: ">=1.2.3,<2.0.0",
+        version: "^1.2.3",
       });
       break;
     }
     case "llamacloud":
       dependencies.push({
         name: "llama-index-indices-managed-llama-cloud",
-        version: ">=0.6.3,<0.7.0",
+        version: "^0.6.3",
       });
       break;
   }
@@ -123,28 +116,28 @@ const getAdditionalDependencies = (
         case "file":
           dependencies.push({
             name: "docx2txt",
-            version: ">=0.8,<0.9",
+            version: "^0.8",
           });
           break;
         case "web":
           dependencies.push({
             name: "llama-index-readers-web",
-            version: ">=0.3.0,<0.4.0",
+            version: "^0.3.0",
           });
           break;
         case "db":
           dependencies.push({
             name: "llama-index-readers-database",
-            version: ">=0.3.0,<0.4.0",
+            version: "^0.3.0",
           });
           dependencies.push({
             name: "pymysql",
-            version: ">=1.1.0,<2.0.0",
+            version: "^1.1.0",
             extras: ["rsa"],
           });
           dependencies.push({
             name: "psycopg2-binary",
-            version: ">=2.9.9,<3.0.0",
+            version: "^2.9.9",
           });
           break;
       }
@@ -163,122 +156,155 @@ const getAdditionalDependencies = (
     case "ollama":
       dependencies.push({
         name: "llama-index-llms-ollama",
-        version: ">=0.5.0,<0.6.0",
+        version: "0.3.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-ollama",
-        version: ">=0.6.0,<0.7.0",
+        version: "0.3.0",
       });
       break;
     case "openai":
       if (templateType !== "multiagent") {
         dependencies.push({
           name: "llama-index-llms-openai",
-          version: ">=0.3.2,<0.4.0",
+          version: "^0.3.2",
         });
         dependencies.push({
           name: "llama-index-embeddings-openai",
-          version: ">=0.3.1,<0.4.0",
+          version: "^0.3.1",
         });
         dependencies.push({
           name: "llama-index-agent-openai",
-          version: ">=0.4.0,<0.5.0",
+          version: "^0.4.0",
         });
       }
       break;
     case "groq":
+      // Fastembed==0.2.0 does not support python3.13 at the moment
+      // Fixed the python version less than 3.13
+      dependencies.push({
+        name: "python",
+        version: "^3.11,<3.13",
+      });
       dependencies.push({
         name: "llama-index-llms-groq",
-        version: ">=0.3.0,<0.4.0",
+        version: "0.2.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-fastembed",
-        version: ">=0.3.0,<0.4.0",
+        version: "^0.2.0",
       });
       break;
     case "anthropic":
+      // Fastembed==0.2.0 does not support python3.13 at the moment
+      // Fixed the python version less than 3.13
+      dependencies.push({
+        name: "python",
+        version: "^3.11,<3.13",
+      });
       dependencies.push({
         name: "llama-index-llms-anthropic",
-        version: ">=0.6.0,<0.7.0",
+        version: "0.3.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-fastembed",
-        version: ">=0.3.0,<0.4.0",
+        version: "^0.2.0",
       });
       break;
     case "gemini":
       dependencies.push({
         name: "llama-index-llms-gemini",
-        version: ">=0.4.0,<0.5.0",
+        version: "0.3.4",
       });
       dependencies.push({
         name: "llama-index-embeddings-gemini",
-        version: ">=0.3.0,<0.4.0",
+        version: "^0.2.0",
       });
       break;
     case "mistral":
       dependencies.push({
         name: "llama-index-llms-mistralai",
-        version: ">=0.4.0,<0.5.0",
+        version: "0.2.1",
       });
       dependencies.push({
         name: "llama-index-embeddings-mistralai",
-        version: ">=0.3.0,<0.4.0",
+        version: "0.2.0",
       });
       break;
     case "azure-openai":
       dependencies.push({
         name: "llama-index-llms-azure-openai",
-        version: ">=0.3.0,<0.4.0",
+        version: "0.2.0",
       });
       dependencies.push({
         name: "llama-index-embeddings-azure-openai",
-        version: ">=0.3.0,<0.4.0",
+        version: "0.2.4",
       });
       break;
     case "huggingface":
       dependencies.push({
         name: "llama-index-llms-huggingface",
-        version: ">=0.5.0,<0.6.0",
+        version: "^0.3.5",
       });
       dependencies.push({
         name: "llama-index-embeddings-huggingface",
-        version: ">=0.5.0,<0.6.0",
+        version: "^0.3.1",
       });
       dependencies.push({
         name: "optimum",
-        version: ">=1.23.3,<2.0.0",
+        version: "^1.23.3",
         extras: ["onnxruntime"],
       });
       break;
     case "t-systems":
       dependencies.push({
         name: "llama-index-agent-openai",
-        version: ">=0.4.0,<0.5.0",
+        version: "0.3.0",
       });
       dependencies.push({
         name: "llama-index-llms-openai-like",
-        version: ">=0.3.0,<0.4.0",
+        version: "0.2.0",
       });
       break;
   }
 
-  if (observability && observability !== "none") {
-    if (observability === "traceloop") {
-      dependencies.push({
-        name: "traceloop-sdk",
-        version: ">=0.15.11",
-      });
+  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 === "llamatrace") {
-      dependencies.push({
-        name: "llama-index-callbacks-arize-phoenix",
-        version: ">=0.3.0,<0.4.0",
-      });
+
+    value.version = dependency.version ?? value.version;
+    value.extras = dependency.extras ?? value.extras;
+
+    // Merge constraints if they exist
+    if (dependency.constraints) {
+      value = { ...value, ...dependency.constraints };
+    }
+
+    if (value.version === undefined) {
+      throw new Error(
+        `Dependency "${dependency.name}" is missing attribute "version"!`,
+      );
+    }
+
+    // Serialize as object if there are any additional properties
+    if (Object.keys(value).length > 1) {
+      existingDependencies[dependency.name] = value;
+    } else {
+      // Otherwise, serialize just the version string
+      existingDependencies[dependency.name] = value.version;
     }
   }
-
-  return dependencies;
 };
 
 const copyRouterCode = async (root: string, tools: Tool[]) => {
@@ -303,100 +329,19 @@ export const addDependencies = async (
     // Parse toml file
     const file = path.join(projectDir, FILENAME);
     const fileContent = await fs.readFile(file, "utf8");
-    let fileParsed: any;
-    try {
-      fileParsed = parse(fileContent);
-    } catch (parseError) {
-      console.error(`Error parsing ${FILENAME}:`, parseError);
-      throw new Error(
-        `Failed to parse ${FILENAME}. Please ensure it's valid TOML.`,
-      );
-    }
+    const fileParsed = parse(fileContent);
 
-    // Ensure [project] and [project.dependencies] exist
-    if (!fileParsed.project) {
-      fileParsed.project = {};
-    }
-    if (
-      !fileParsed.project.dependencies ||
-      !Array.isArray(fileParsed.project.dependencies)
-    ) {
-      // If dependencies exist but aren't an array, log a warning or error.
-      // For now, we'll overwrite it, assuming the intent is to use the standard array format.
-      console.warn(
-        `[project.dependencies] in ${FILENAME} is not an array. It will be overwritten.`,
-      );
-      fileParsed.project.dependencies = [];
-    }
-
-    const existingDependencies: string[] = fileParsed.project.dependencies;
-    const addedDeps: string[] = [];
-    const updatedDeps: string[] = [];
-
-    // Add or update dependencies
-    for (const newDep of dependencies) {
-      let depString = newDep.name;
-      if (newDep.extras && newDep.extras.length > 0) {
-        depString += `[${newDep.extras.join(",")}]`;
-      }
-      if (newDep.version) {
-        depString += newDep.version;
-      }
-
-      let found = false;
-      for (let i = 0; i < existingDependencies.length; i++) {
-        const existingDepNameMatch =
-          existingDependencies[i].match(/^([a-zA-Z0-9._-]+)/);
-        if (
-          existingDepNameMatch &&
-          existingDepNameMatch[1].toLowerCase() === depString.toLowerCase()
-        ) {
-          // Found existing dependency, update it
-          if (existingDependencies[i] !== depString) {
-            updatedDeps.push(`${existingDependencies[i]} -> ${depString}`);
-            existingDependencies[i] = depString;
-          }
-          found = true;
-          break;
-        }
-      }
-
-      if (!found) {
-        // Add new dependency
-        existingDependencies.push(depString);
-        addedDeps.push(depString);
-      }
-      // Handle python version constraints separately (if any)
-      if (newDep.constraints?.python) {
-        if (
-          !fileParsed.project["requires-python"] ||
-          fileParsed.project["requires-python"] !== newDep.constraints.python
-        ) {
-          // This simple overwrite might not be ideal; merging constraints is complex.
-          // For now, let's just set it if the new dependency has one.
-          console.log(
-            `Setting requires-python = "${newDep.constraints.python}" from dependency ${newDep.name}`,
-          );
-          fileParsed.project["requires-python"] = newDep.constraints.python;
-        }
-      }
-    }
+    // Modify toml dependencies
+    const tool = fileParsed.tool as any;
+    const existingDependencies = tool.poetry.dependencies;
+    mergePoetryDependencies(dependencies, existingDependencies);
 
     // Write toml file
     const newFileContent = stringify(fileParsed);
     await fs.writeFile(file, newFileContent);
 
-    if (addedDeps.length > 0) {
-      console.log(`\nAdded dependencies to ${cyan(FILENAME)}:`);
-      addedDeps.forEach((dep) => console.log(`  ${dep}`));
-    }
-    if (updatedDeps.length > 0) {
-      console.log(`\nUpdated dependencies in ${cyan(FILENAME)}:`);
-      updatedDeps.forEach((dep) => console.log(`  ${dep}`));
-    }
-    if (addedDeps.length > 0 || updatedDeps.length > 0) {
-      console.log(""); // Newline for spacing
-    }
+    const dependenciesString = dependencies.map((d) => d.name).join(", ");
+    console.log(`\nAdded ${dependenciesString} to ${cyan(FILENAME)}\n`);
   } catch (error) {
     console.log(
       `Error while updating dependencies for Poetry project file ${FILENAME}\n`,
@@ -405,16 +350,18 @@ export const addDependencies = async (
   }
 };
 
-export const installPythonDependencies = () => {
-  if (isUvAvailable()) {
+export const installPythonDependencies = (
+  { noRoot }: { noRoot: boolean } = { noRoot: false },
+) => {
+  if (isPoetryAvailable()) {
     console.log(
-      `Installing Python dependencies using uv. This may take a while...`,
+      `Installing python dependencies using poetry. This may take a while...`,
     );
-    const installSuccessful = tryUvSync();
+    const installSuccessful = tryPoetryInstall(noRoot);
     if (!installSuccessful) {
       console.error(
         red(
-          "Installing dependencies using uv failed. Please check the error log above and ensure uv is installed correctly.",
+          "Installing dependencies using poetry failed. Please check error log above and try running create-llama again.",
         ),
       );
       process.exit(1);
@@ -422,195 +369,16 @@ export const installPythonDependencies = () => {
   } else {
     console.error(
       red(
-        `uv is not available in the current environment. Please check ${terminalLink(
-          "uv Installation",
-          `https://github.com/astral-sh/uv#installation`,
-        )} to install uv first, then run create-llama again.`,
+        `Poetry is not available in the current environment. Please check ${terminalLink(
+          "Poetry Installation",
+          `https://python-poetry.org/docs/#installation`,
+        )} to install poetry first, then run create-llama again.`,
       ),
     );
     process.exit(1);
   }
 };
 
-const installLegacyPythonTemplate = async ({
-  root,
-  template,
-  vectorDb,
-  dataSources,
-  tools,
-  useCase,
-  observability,
-}: Pick<
-  InstallTemplateArgs,
-  | "root"
-  | "template"
-  | "vectorDb"
-  | "dataSources"
-  | "tools"
-  | "useCase"
-  | "observability"
->) => {
-  const compPath = path.join(templatesDir, "components");
-  const enginePath = path.join(root, "app", "engine");
-
-  // Copy selected vector DB
-  await copy("**", enginePath, {
-    parents: true,
-    cwd: path.join(compPath, "vectordbs", "python", vectorDb ?? "none"),
-  });
-
-  if (vectorDb !== "llamacloud") {
-    // Copy all loaders to enginePath
-    // Not needed for LlamaCloud as it has its own loaders
-    const loaderPath = path.join(enginePath, "loaders");
-    await copy("**", loaderPath, {
-      parents: true,
-      cwd: path.join(compPath, "loaders", "python"),
-    });
-  }
-
-  // Copy settings.py to app
-  await copy("**", path.join(root, "app"), {
-    cwd: path.join(compPath, "settings", "python"),
-  });
-
-  // Copy services
-  if (template == "streaming" || template == "multiagent") {
-    await copy("**", path.join(root, "app", "api", "services"), {
-      cwd: path.join(compPath, "services", "python"),
-    });
-  }
-  // Copy engine code
-  if (template === "streaming" || template === "multiagent") {
-    // Select and copy engine code based on data sources and tools
-    let engine;
-    // Multiagent always uses agent engine
-    if (template === "multiagent") {
-      engine = "agent";
-    } else {
-      // For streaming, use chat engine by default
-      // Unless tools are selected, in which case use agent engine
-      if (dataSources.length > 0 && (!tools || tools.length === 0)) {
-        console.log(
-          "\nNo tools selected - use optimized context chat engine\n",
-        );
-        engine = "chat";
-      } else {
-        engine = "agent";
-      }
-    }
-
-    // Copy engine code
-    await copy("**", enginePath, {
-      parents: true,
-      cwd: path.join(compPath, "engines", "python", engine),
-    });
-
-    // Copy router code
-    await copyRouterCode(root, tools ?? []);
-  }
-
-  // Copy multiagents overrides
-  if (template === "multiagent") {
-    await copy("**", path.join(root), {
-      cwd: path.join(compPath, "multiagent", "python"),
-    });
-  }
-
-  if (template === "multiagent" || template === "reflex") {
-    if (useCase) {
-      const sourcePath =
-        template === "multiagent"
-          ? path.join(compPath, "agents", "python", useCase)
-          : path.join(compPath, "reflex", useCase);
-
-      await copy("**", path.join(root), {
-        parents: true,
-        cwd: sourcePath,
-        rename: assetRelocator,
-      });
-    } else {
-      console.log(
-        red(
-          `There is no use case selected for ${template} template. Please pick a use case to use via --use-case flag.`,
-        ),
-      );
-      process.exit(1);
-    }
-  }
-
-  if (observability && observability !== "none") {
-    const templateObservabilityPath = path.join(
-      templatesDir,
-      "components",
-      "observability",
-      "python",
-      observability,
-    );
-    await copy("**", path.join(root, "app"), {
-      cwd: templateObservabilityPath,
-    });
-  }
-};
-
-const installLlamaIndexServerTemplate = async ({
-  root,
-  useCase,
-  useLlamaParse,
-}: Pick<InstallTemplateArgs, "root" | "useCase" | "useLlamaParse">) => {
-  if (!useCase) {
-    console.log(
-      red(
-        `There is no use case selected. Please pick a use case to use via --use-case flag.`,
-      ),
-    );
-    process.exit(1);
-  }
-
-  await copy("*.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,
@@ -644,7 +412,7 @@ export const installPythonTemplate = async ({
   if (template === "reflex") {
     templatePath = path.join(templatesDir, "types", "reflex");
   } else {
-    templatePath = path.join(templatesDir, "types", template, framework);
+    templatePath = path.join(templatesDir, "types", "streaming", framework);
   }
   await copy("**", root, {
     parents: true,
@@ -652,34 +420,101 @@ export const installPythonTemplate = async ({
     rename: assetRelocator,
   });
 
-  if (template === "llamaindexserver") {
-    await installLlamaIndexServerTemplate({
-      root,
-      useCase,
-      useLlamaParse,
-    });
-  } else {
-    await installLegacyPythonTemplate({
-      root,
-      template,
-      vectorDb,
-      dataSources,
-      tools,
-      useCase,
-      observability,
+  const compPath = path.join(templatesDir, "components");
+  const enginePath = path.join(root, "app", "engine");
+
+  // Copy selected vector DB
+  await copy("**", enginePath, {
+    parents: true,
+    cwd: path.join(compPath, "vectordbs", "python", vectorDb ?? "none"),
+  });
+
+  if (vectorDb !== "llamacloud") {
+    // Copy all loaders to enginePath
+    // Not needed for LlamaCloud as it has its own loaders
+    const loaderPath = path.join(enginePath, "loaders");
+    await copy("**", loaderPath, {
+      parents: true,
+      cwd: path.join(compPath, "loaders", "python"),
     });
   }
 
+  // Copy settings.py to app
+  await copy("**", path.join(root, "app"), {
+    cwd: path.join(compPath, "settings", "python"),
+  });
+
+  if (template == "streaming" || template == "multiagent") {
+    // Copy services
+    await copy("**", path.join(root, "app", "api", "services"), {
+      cwd: path.join(compPath, "services", "python"),
+    });
+    // Copy router code
+    await copyRouterCode(root, tools ?? []);
+  }
+
+  if (template === "multiagent" || template === "reflex") {
+    if (useCase) {
+      const sourcePath =
+        template === "multiagent"
+          ? path.join(compPath, "agents", "python", useCase)
+          : path.join(compPath, "reflex", useCase);
+
+      await copy("**", path.join(root), {
+        parents: true,
+        cwd: sourcePath,
+        rename: assetRelocator,
+      });
+    } else {
+      console.log(
+        red(
+          `There is no use case selected for ${template} template. Please pick a use case to use via --use-case flag.`,
+        ),
+      );
+      process.exit(1);
+    }
+  }
+
   console.log("Adding additional dependencies");
+
   const addOnDependencies = getAdditionalDependencies(
     modelConfig,
     vectorDb,
     dataSources,
     tools,
     template,
-    observability,
   );
 
+  if (observability && observability !== "none") {
+    if (observability === "traceloop") {
+      addOnDependencies.push({
+        name: "traceloop-sdk",
+        version: "^0.15.11",
+      });
+    }
+
+    if (observability === "llamatrace") {
+      addOnDependencies.push({
+        name: "llama-index-callbacks-arize-phoenix",
+        version: "^0.3.0",
+        constraints: {
+          python: ">=3.11,<3.13",
+        },
+      });
+    }
+
+    const templateObservabilityPath = path.join(
+      templatesDir,
+      "components",
+      "observability",
+      "python",
+      observability,
+    );
+    await copy("**", path.join(root, "app"), {
+      cwd: templateObservabilityPath,
+    });
+  }
+
   await addDependencies(root, addOnDependencies);
 
   if (postInstallAction === "runApp" || postInstallAction === "dependencies") {

helpers/run-app.ts

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

helpers/tools.ts

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

helpers/types.ts

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

helpers/typescript.ts

@@ -1,108 +1,49 @@
 import fs from "fs/promises";
 import os from "os";
 import path from "path";
-import { bold, cyan, red, yellow } from "picocolors";
+import { bold, cyan, yellow } from "picocolors";
 import { assetRelocator, copy } from "../helpers/copy";
 import { callPackageManager } from "../helpers/install";
 import { templatesDir } from "./dir";
 import { PackageManager } from "./get-pkg-manager";
 import { InstallTemplateArgs, ModelProvider, TemplateVectorDB } from "./types";
 
-const installLlamaIndexServerTemplate = async ({
-  root,
-  useCase,
-  vectorDb,
-}: Pick<InstallTemplateArgs, "root" | "useCase" | "vectorDb">) => {
-  if (!useCase) {
-    console.log(
-      red(
-        `There is no use case selected. Please pick a use case to use via --use-case flag.`,
-      ),
-    );
-    process.exit(1);
-  }
-
-  if (!vectorDb) {
-    console.log(
-      red(
-        `There is no vector db selected. Please pick a vector db to use via --vector-db flag.`,
-      ),
-    );
-    process.exit(1);
-  }
-
-  await copy("**", 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 ({
+/**
+ * Install a LlamaIndex internal template to a given `root` directory.
+ */
+export const installTSTemplate = async ({
+  appName,
   root,
+  packageManager,
+  isOnline,
   template,
-  backend,
   framework,
   ui,
   vectorDb,
+  postInstallAction,
+  backend,
   observability,
   tools,
   dataSources,
   useLlamaParse,
   useCase,
   modelConfig,
-  relativeEngineDestPath,
-}: InstallTemplateArgs & {
-  backend: boolean;
-  relativeEngineDestPath: string;
-}) => {
+}: InstallTemplateArgs & { backend: boolean }) => {
+  console.log(bold(`Using ${packageManager}.`));
+
+  /**
+   * Copy the template files to the target directory.
+   */
+  console.log("\nInitializing project with template:", template, "\n");
+  const templatePath = path.join(templatesDir, "types", "streaming", framework);
+  const copySource = ["**"];
+
+  await copy(copySource, root, {
+    parents: true,
+    cwd: templatePath,
+    rename: assetRelocator,
+  });
+
   /**
    * If next.js is used, update its configuration if necessary
    */
@@ -157,6 +98,10 @@ const installLegacyTSTemplate = async ({
   }
 
   const compPath = path.join(templatesDir, "components");
+  const relativeEngineDestPath =
+    framework === "nextjs"
+      ? path.join("app", "api", "chat")
+      : path.join("src", "controllers");
   const enginePath = path.join(root, relativeEngineDestPath, "engine");
 
   // copy llamaindex code for TS templates
@@ -178,56 +123,25 @@ const installLegacyTSTemplate = async ({
     cwd: path.join(compPath, "vectordbs", "typescript", vectorDb ?? "none"),
   });
 
-  if (template === "multiagent") {
-    const multiagentPath = path.join(compPath, "multiagent", "typescript");
+  if (template === "multiagent" && useCase) {
+    // Copy use case code for multiagent template
+    console.log("\nCopying use case:", useCase, "\n");
+    const useCasePath = path.join(compPath, "agents", "typescript", useCase);
+    const useCaseCodePath = path.join(useCasePath, "workflow");
 
-    // copy workflow code for multiagent template
+    // Copy use case codes
     await copy("**", path.join(root, relativeEngineDestPath, "workflow"), {
       parents: true,
-      cwd: path.join(multiagentPath, "workflow"),
+      cwd: useCaseCodePath,
+      rename: assetRelocator,
     });
 
-    // Copy use case code for multiagent template
-    if (useCase) {
-      console.log("\nCopying use case:", useCase, "\n");
-      const useCasePath = path.join(compPath, "agents", "typescript", useCase);
-      const useCaseCodePath = path.join(useCasePath, "workflow");
-
-      // Copy use case codes
-      await copy("**", path.join(root, relativeEngineDestPath, "workflow"), {
-        parents: true,
-        cwd: useCaseCodePath,
-        rename: assetRelocator,
-      });
-
-      // Copy use case files to project root
-      await copy("*.*", path.join(root), {
-        parents: true,
-        cwd: useCasePath,
-        rename: assetRelocator,
-      });
-    } else {
-      console.log(
-        red(
-          `There is no use case selected for ${template} template. Please pick a use case to use via --use-case flag.`,
-        ),
-      );
-      process.exit(1);
-    }
-
-    if (framework === "nextjs") {
-      // patch route.ts file
-      await copy("**", path.join(root, relativeEngineDestPath), {
-        parents: true,
-        cwd: path.join(multiagentPath, "nextjs"),
-      });
-    } else if (framework === "express") {
-      // patch chat.controller.ts file
-      await copy("**", path.join(root, relativeEngineDestPath), {
-        parents: true,
-        cwd: path.join(multiagentPath, "express"),
-      });
-    }
+    // Copy use case files to project root
+    await copy("*.*", path.join(root), {
+      parents: true,
+      cwd: useCasePath,
+      rename: assetRelocator,
+    });
   }
 
   // copy loader component (TS only supports llama_parse and file for now)
@@ -291,75 +205,6 @@ const installLegacyTSTemplate = async ({
     await fs.rm(path.join(root, "app", "api"), { recursive: true });
     await fs.rm(path.join(root, "config"), { recursive: true, force: true });
   }
-};
-
-/**
- * Install a LlamaIndex internal template to a given `root` directory.
- */
-export const installTSTemplate = async ({
-  appName,
-  root,
-  packageManager,
-  isOnline,
-  template,
-  framework,
-  ui,
-  vectorDb,
-  postInstallAction,
-  backend,
-  observability,
-  tools,
-  dataSources,
-  useLlamaParse,
-  useCase,
-  modelConfig,
-}: InstallTemplateArgs & { backend: boolean }) => {
-  console.log(bold(`Using ${packageManager}.`));
-
-  /**
-   * Copy the template files to the target directory.
-   */
-  console.log("\nInitializing project with template:", template, "\n");
-  const templatePath = path.join(templatesDir, "types", template, framework);
-  const copySource = ["**"];
-
-  await copy(copySource, root, {
-    parents: true,
-    cwd: templatePath,
-    rename: assetRelocator,
-  });
-
-  const relativeEngineDestPath =
-    framework === "nextjs"
-      ? path.join("app", "api", "chat")
-      : path.join("src", "controllers");
-
-  if (template === "llamaindexserver") {
-    await installLlamaIndexServerTemplate({
-      root,
-      useCase,
-      vectorDb,
-    });
-  } else {
-    await installLegacyTSTemplate({
-      appName,
-      root,
-      packageManager,
-      isOnline,
-      template,
-      backend,
-      framework,
-      ui,
-      vectorDb,
-      observability,
-      tools,
-      dataSources,
-      useLlamaParse,
-      useCase,
-      modelConfig,
-      relativeEngineDestPath,
-    });
-  }
 
   const packageJson = await updatePackageJson({
     root,
@@ -372,7 +217,6 @@ export const installTSTemplate = async ({
     vectorDb,
     backend,
     modelConfig,
-    template,
   });
 
   if (
@@ -387,27 +231,27 @@ const providerDependencies: {
   [key in ModelProvider]?: Record<string, string>;
 } = {
   openai: {
-    "@llamaindex/openai": "~0.4.0",
+    "@llamaindex/openai": "^0.1.52",
   },
   gemini: {
-    "@llamaindex/google": "^0.2.0",
+    "@llamaindex/google": "^0.0.7",
   },
   ollama: {
-    "@llamaindex/ollama": "^0.1.0",
+    "@llamaindex/ollama": "^0.0.40",
   },
   mistral: {
-    "@llamaindex/mistral": "^0.2.0",
+    "@llamaindex/mistral": "^0.0.5",
   },
   "azure-openai": {
-    "@llamaindex/openai": "^0.2.0",
+    "@llamaindex/openai": "^0.1.52",
   },
   groq: {
-    "@llamaindex/groq": "^0.0.61",
-    "@llamaindex/huggingface": "^0.1.0", // groq uses huggingface as default embedding model
+    "@llamaindex/groq": "^0.0.51",
+    "@llamaindex/huggingface": "^0.0.36", // groq uses huggingface as default embedding model
   },
   anthropic: {
-    "@llamaindex/anthropic": "^0.3.0",
-    "@llamaindex/huggingface": "^0.1.0", // anthropic uses huggingface as default embedding model
+    "@llamaindex/anthropic": "^0.1.0",
+    "@llamaindex/huggingface": "^0.0.36", // anthropic uses huggingface as default embedding model
   },
 };
 
@@ -456,7 +300,6 @@ async function updatePackageJson({
   vectorDb,
   backend,
   modelConfig,
-  template,
 }: Pick<
   InstallTemplateArgs,
   | "root"
@@ -467,7 +310,6 @@ async function updatePackageJson({
   | "observability"
   | "vectorDb"
   | "modelConfig"
-  | "template"
 > & {
   relativeEngineDestPath: string;
   backend: boolean;
@@ -479,7 +321,7 @@ async function updatePackageJson({
   packageJson.name = appName;
   packageJson.version = "0.1.0";
 
-  if (relativeEngineDestPath && template !== "llamaindexserver") {
+  if (relativeEngineDestPath) {
     // TODO: move script to {root}/scripts for all frameworks
     // add generate script if using context engine
     packageJson.scripts = {
@@ -513,7 +355,7 @@ async function updatePackageJson({
   if (backend) {
     packageJson.dependencies = {
       ...packageJson.dependencies,
-      "@llamaindex/readers": "~3.1.4",
+      "@llamaindex/readers": "^2.0.0",
     };
 
     if (vectorDb && vectorDb in vectorDbDependencies) {
@@ -543,16 +385,6 @@ async function updatePackageJson({
     };
   }
 
-  // if having custom server package tgz file, use it for testing @llamaindex/server
-  const serverPackagePath = process.env.SERVER_PACKAGE_PATH;
-  if (serverPackagePath && template === "llamaindexserver") {
-    const relativePath = path.relative(process.cwd(), serverPackagePath);
-    packageJson.dependencies = {
-      ...packageJson.dependencies,
-      "@llamaindex/server": `file:${relativePath}`,
-    };
-  }
-
   await fs.writeFile(
     packageJsonFile,
     JSON.stringify(packageJson, null, 2) + os.EOL,

helpers/validate-pkg.ts

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

index.ts

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

package.json

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

packages/create-llama/.gitignore

@@ -1,65 +0,0 @@
-# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
-
-# dependencies
-node_modules
-.pnp
-.pnpm-store
-.pnp.js
-
-# testing
-coverage
-.coverage
-
-# next.js
-.next/
-out/
-build
-
-# misc
-.DS_Store
-*.pem
-
-# debug
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# local env files
-.env
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-
-# build
-dist/
-lib/
-
-# e2e
-.cache
-test-results/
-playwright-report/
-blob-report/
-playwright/.cache/
-.tsbuildinfo
-e2e/cache
-
-# intellij
-**/.idea
-
-# Python
-.mypy_cache/
-venv/
-.venv/
-dist/
-.__pycache__
-__pycache__
-.python-version
-.ui
-
-# build artifacts
-create-llama-*.tgz
-
-# copied from root
-README.md
-LICENSE.md

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

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

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

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

packages/create-llama/helpers/uv.ts

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

packages/create-llama/package.json

@@ -1,76 +0,0 @@
-{
-  "name": "create-llama",
-  "version": "0.5.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/questions/simple.ts

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

packages/create-llama/templates/components/engines/python/chat/engine.py

@@ -1,47 +0,0 @@
-import os
-
-from app.engine.index import IndexConfig, get_index
-from app.engine.node_postprocessors import NodeCitationProcessor
-from fastapi import HTTPException
-from llama_index.core.callbacks import CallbackManager
-from llama_index.core.chat_engine import CondensePlusContextChatEngine
-from llama_index.core.memory import ChatMemoryBuffer
-from llama_index.core.settings import Settings
-
-
-def get_chat_engine(params=None, event_handlers=None, **kwargs):
-    system_prompt = os.getenv("SYSTEM_PROMPT")
-    citation_prompt = os.getenv("SYSTEM_CITATION_PROMPT", None)
-    top_k = int(os.getenv("TOP_K", 0))
-    llm = Settings.llm
-    memory = ChatMemoryBuffer.from_defaults(
-        token_limit=llm.metadata.context_window - 256
-    )
-    callback_manager = CallbackManager(handlers=event_handlers or [])
-
-    node_postprocessors = []
-    if citation_prompt:
-        node_postprocessors = [NodeCitationProcessor()]
-        system_prompt = f"{system_prompt}\n{citation_prompt}"
-
-    index_config = IndexConfig(callback_manager=callback_manager, **(params or {}))
-    index = get_index(index_config)
-    if index is None:
-        raise HTTPException(
-            status_code=500,
-            detail=str(
-                "StorageContext is empty - call 'uv run generate' to generate the storage first"
-            ),
-        )
-    if top_k != 0 and kwargs.get("similarity_top_k") is None:
-        kwargs["similarity_top_k"] = top_k
-    retriever = index.as_retriever(**kwargs)
-
-    return CondensePlusContextChatEngine(
-        llm=llm,
-        memory=memory,
-        system_prompt=system_prompt,
-        retriever=retriever,
-        node_postprocessors=node_postprocessors,  # type: ignore
-        callback_manager=callback_manager,
-    )

packages/create-llama/templates/components/engines/python/chat/node_postprocessors.py

@@ -1,21 +0,0 @@
-from typing import List, Optional
-
-from llama_index.core import QueryBundle
-from llama_index.core.postprocessor.types import BaseNodePostprocessor
-from llama_index.core.schema import NodeWithScore
-
-
-class NodeCitationProcessor(BaseNodePostprocessor):
-    """
-    Append node_id into metadata for citation purpose.
-    Config SYSTEM_CITATION_PROMPT in your runtime environment variable to enable this feature.
-    """
-
-    def _postprocess_nodes(
-        self,
-        nodes: List[NodeWithScore],
-        query_bundle: Optional[QueryBundle] = None,
-    ) -> List[NodeWithScore]:
-        for node_score in nodes:
-            node_score.node.metadata["node_id"] = node_score.node.node_id
-        return nodes

packages/create-llama/templates/components/multiagent/python/app/workflows/function_calling_agent.py

@@ -1,121 +0,0 @@
-from typing import Any, List, Optional
-
-from app.workflows.events import AgentRunEvent
-from app.workflows.tools import ToolCallResponse, call_tools, chat_with_tools
-from llama_index.core.base.llms.types import ChatMessage
-from llama_index.core.llms.function_calling import FunctionCallingLLM
-from llama_index.core.memory import ChatMemoryBuffer
-from llama_index.core.settings import Settings
-from llama_index.core.tools.types import BaseTool
-from llama_index.core.workflow import (
-    Context,
-    Event,
-    StartEvent,
-    StopEvent,
-    Workflow,
-    step,
-)
-
-
-class InputEvent(Event):
-    input: list[ChatMessage]
-
-
-class ToolCallEvent(Event):
-    input: ToolCallResponse
-
-
-class FunctionCallingAgent(Workflow):
-    """
-    A simple workflow to request LLM with tools independently.
-    You can share the previous chat history to provide the context for the LLM.
-    """
-
-    def __init__(
-        self,
-        *args: Any,
-        llm: FunctionCallingLLM | None = None,
-        chat_history: Optional[List[ChatMessage]] = None,
-        tools: List[BaseTool] | None = None,
-        system_prompt: str | None = None,
-        verbose: bool = False,
-        timeout: float = 360.0,
-        name: str,
-        write_events: bool = True,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(*args, verbose=verbose, timeout=timeout, **kwargs)  # type: ignore
-        self.tools = tools or []
-        self.name = name
-        self.write_events = write_events
-
-        if llm is None:
-            llm = Settings.llm
-        self.llm = llm
-        if not self.llm.metadata.is_function_calling_model:
-            raise ValueError("The provided LLM must support function calling.")
-
-        self.system_prompt = system_prompt
-
-        self.memory = ChatMemoryBuffer.from_defaults(
-            llm=self.llm, chat_history=chat_history
-        )
-        self.sources = []  # type: ignore
-
-    @step()
-    async def prepare_chat_history(self, ctx: Context, ev: StartEvent) -> InputEvent:
-        # clear sources
-        self.sources = []
-
-        # set streaming
-        ctx.data["streaming"] = getattr(ev, "streaming", False)
-
-        # set system prompt
-        if self.system_prompt is not None:
-            system_msg = ChatMessage(role="system", content=self.system_prompt)
-            self.memory.put(system_msg)
-
-        # get user input
-        user_input = ev.input
-        user_msg = ChatMessage(role="user", content=user_input)
-        self.memory.put(user_msg)
-
-        if self.write_events:
-            ctx.write_event_to_stream(
-                AgentRunEvent(name=self.name, msg=f"Start to work on: {user_input}")
-            )
-
-        return InputEvent(input=self.memory.get())
-
-    @step()
-    async def handle_llm_input(
-        self,
-        ctx: Context,
-        ev: InputEvent,
-    ) -> ToolCallEvent | StopEvent:
-        chat_history = ev.input
-
-        response = await chat_with_tools(
-            self.llm,
-            self.tools,
-            chat_history,
-        )
-        is_tool_call = isinstance(response, ToolCallResponse)
-        if not is_tool_call:
-            if ctx.data["streaming"]:
-                return StopEvent(result=response)
-            else:
-                full_response = ""
-                async for chunk in response.generator:
-                    full_response += chunk.message.content
-                return StopEvent(result=full_response)
-        return ToolCallEvent(input=response)
-
-    @step()
-    async def handle_tool_calls(self, ctx: Context, ev: ToolCallEvent) -> InputEvent:
-        tool_calls = ev.input.tool_calls
-        tool_call_message = ev.input.tool_call_message
-        self.memory.put(tool_call_message)
-        tool_messages = await call_tools(self.name, self.tools, ctx, tool_calls)
-        self.memory.put_messages(tool_messages)
-        return InputEvent(input=self.memory.get())

packages/create-llama/templates/components/multiagent/typescript/workflow/stream.ts

@@ -1,69 +0,0 @@
-import {
-  StopEvent,
-  WorkflowContext,
-  WorkflowEvent,
-} from "@llamaindex/workflow";
-import { StreamData } from "ai";
-import { ChatResponseChunk, EngineResponse } from "llamaindex";
-import { ReadableStream } from "stream/web";
-import { AgentRunEvent } from "./type";
-
-export async function createStreamFromWorkflowContext<Input, Output, Context>(
-  context: WorkflowContext<Input, Output, Context>,
-): Promise<{ stream: ReadableStream<EngineResponse>; dataStream: StreamData }> {
-  const dataStream = new StreamData();
-  let generator: AsyncGenerator<ChatResponseChunk> | undefined;
-
-  const closeStreams = (controller: ReadableStreamDefaultController) => {
-    controller.close();
-    dataStream.close();
-  };
-
-  const stream = new ReadableStream<EngineResponse>({
-    async start(controller) {
-      // Kickstart the stream by sending an empty string
-      controller.enqueue({ delta: "" } as EngineResponse);
-    },
-    async pull(controller) {
-      while (!generator) {
-        // get next event from workflow context
-        const { value: event, done } =
-          await context[Symbol.asyncIterator]().next();
-        if (done) {
-          closeStreams(controller);
-          return;
-        }
-        generator = handleEvent(event, dataStream);
-      }
-
-      const { value: chunk, done } = await generator.next();
-      if (done) {
-        closeStreams(controller);
-        return;
-      }
-      const delta = chunk.delta ?? "";
-      if (delta) {
-        controller.enqueue({ delta } as EngineResponse);
-      }
-    },
-  });
-
-  return { stream, dataStream };
-}
-
-function handleEvent(
-  event: WorkflowEvent<any>,
-  dataStream: StreamData,
-): AsyncGenerator<ChatResponseChunk> | undefined {
-  // Handle for StopEvent
-  if (event instanceof StopEvent) {
-    return event.data as AsyncGenerator<ChatResponseChunk>;
-  }
-  // Handle for AgentRunEvent
-  if (event instanceof AgentRunEvent) {
-    dataStream.appendMessageAnnotation({
-      type: "agent",
-      data: event.data,
-    });
-  }
-}

packages/create-llama/templates/components/reflex/contract_review/pyproject.toml

@@ -1,34 +0,0 @@
-[project]
-name = "app"
-version = "0.1.0"
-description = ""
-authors = [ { name = "Marcus Schiesser", email = "mail@marcusschiesser.de" } ]
-readme = "README.md"
-requires-python = ">=3.11,<4.0"
-dependencies = [
-    "fastapi>=0.109.1",
-    "python-dotenv>=1.0.0",
-    "pydantic<2.10",
-    "llama-index>=0.12.1",
-    "llama-parse>=0.6.21,<0.7.0",
-    "cachetools>=5.3.3",
-    "reflex==0.7.10",
-]
-
-[project.scripts]
-generate = "app.engine.generate:generate_datasource"
-
-[project.optional-dependencies]
-dev = [
-    "mypy>=1.8.0",
-    "pytest>=8.3.5",
-    "pytest-asyncio>=0.25.3",
-    "docx2txt>=0.8",
-    "llama-index-llms-openai>=0.3.2",
-    "llama-index-embeddings-openai>=0.3.1",
-    "llama-index-agent-openai>=0.4.0",
-]
-
-[build-system]
-requires = [ "hatchling>=1.24" ]
-build-backend = "hatchling.build"

packages/create-llama/templates/components/reflex/extractor/pyproject.toml

@@ -1,31 +0,0 @@
-[project]
-name = "app"
-version = "0.1.0"
-description = ""
-authors = [ { name = "Marcus Schiesser", email = "mail@marcusschiesser.de" } ]
-readme = "README.md"
-requires-python = ">=3.11,<4.0"
-dependencies = [
-    "fastapi>=0.109.1",
-    "uvicorn>=0.23.2",
-    "python-dotenv>=1.0.0",
-    "pydantic<2.10",
-    "llama-index>=0.12.1",
-    "llama-parse>=0.6.21,<0.7.0",
-    "cachetools>=5.3.3",
-    "reflex==0.7.10",
-]
-
-[project.scripts]
-generate = "app.engine.generate:generate_datasource"
-
-[project.optional-dependencies]
-dev = [
-    "mypy>=1.8.0",
-    "pytest>=8.3.5",
-    "pytest-asyncio>=0.25.3",
-]
-
-[build-system]
-requires = [ "hatchling>=1.24" ]
-build-backend = "hatchling.build"

packages/create-llama/templates/components/ui/use-cases/code_generator/ui_event.jsx

@@ -1,132 +0,0 @@
-import { Badge } from "@/components/ui/badge";
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
-import { Progress } from "@/components/ui/progress";
-import { Skeleton } from "@/components/ui/skeleton";
-import { cn } from "@/lib/utils";
-import { Markdown } from "@llamaindex/chat-ui/widgets";
-import { ListChecks, Loader2, Wand2 } from "lucide-react";
-import { useEffect, useState } from "react";
-
-const STAGE_META = {
-  plan: {
-    icon: ListChecks,
-    badgeText: "Step 1/2: Planning",
-    gradient: "from-blue-100 via-blue-50 to-white",
-    progress: 33,
-    iconBg: "bg-blue-100 text-blue-600",
-    badge: "bg-blue-100 text-blue-700",
-  },
-  generate: {
-    icon: Wand2,
-    badgeText: "Step 2/2: Generating",
-    gradient: "from-violet-100 via-violet-50 to-white",
-    progress: 66,
-    iconBg: "bg-violet-100 text-violet-600",
-    badge: "bg-violet-100 text-violet-700",
-  },
-};
-
-function ArtifactWorkflowCard({ event }) {
-  const [visible, setVisible] = useState(event?.state !== "completed");
-  const [fade, setFade] = useState(false);
-
-  useEffect(() => {
-    if (event?.state === "completed") {
-      setVisible(false);
-    } else {
-      setVisible(true);
-      setFade(false);
-    }
-  }, [event?.state]);
-
-  if (!event || !visible) return null;
-
-  const { state, requirement } = event;
-  const meta = STAGE_META[state];
-
-  if (!meta) return null;
-
-  return (
-    <div className="flex min-h-[180px] w-full items-center justify-center py-2">
-      <Card
-        className={cn(
-          "w-full rounded-xl shadow-md transition-all duration-500",
-          "border-0",
-          fade && "pointer-events-none opacity-0",
-          `bg-gradient-to-br ${meta.gradient}`,
-        )}
-        style={{
-          boxShadow:
-            "0 2px 12px 0 rgba(80, 80, 120, 0.08), 0 1px 3px 0 rgba(80, 80, 120, 0.04)",
-        }}
-      >
-        <CardHeader className="flex flex-row items-center gap-2 px-3 pb-1 pt-2">
-          <div
-            className={cn(
-              "flex items-center justify-center rounded-full p-1",
-              meta.iconBg,
-            )}
-          >
-            <meta.icon className="h-5 w-5" />
-          </div>
-          <CardTitle className="flex items-center gap-2 text-base font-semibold">
-            <Badge className={cn("ml-1", meta.badge, "px-2 py-0.5 text-xs")}>
-              {meta.badgeText}
-            </Badge>
-          </CardTitle>
-        </CardHeader>
-        <CardContent className="px-3 py-1">
-          {state === "plan" && (
-            <div className="flex flex-col items-center gap-2 py-2">
-              <Loader2 className="mb-1 h-6 w-6 animate-spin text-blue-400" />
-              <div className="text-center text-sm font-medium text-blue-900">
-                Analyzing your request...
-              </div>
-              <Skeleton className="mt-1 h-3 w-1/2 rounded-full" />
-            </div>
-          )}
-          {state === "generate" && (
-            <div className="flex flex-col gap-2 py-2">
-              <div className="flex items-center gap-1">
-                <Loader2 className="h-4 w-4 animate-spin text-violet-400" />
-                <span className="text-sm font-medium text-violet-900">
-                  Working on the requirement:
-                </span>
-              </div>
-              <div className="max-h-24 overflow-auto rounded-lg border border-violet-200 bg-violet-50 px-2 py-1 text-xs">
-                {requirement ? (
-                  <Markdown content={requirement} />
-                ) : (
-                  <span className="italic text-violet-400">
-                    No requirements available yet.
-                  </span>
-                )}
-              </div>
-            </div>
-          )}
-        </CardContent>
-        <div className="px-3 pb-2 pt-1">
-          <Progress
-            value={meta.progress}
-            className={cn(
-              "h-1 rounded-full bg-gray-200",
-              state === "plan" && "bg-blue-200",
-              state === "generate" && "bg-violet-200",
-            )}
-          />
-        </div>
-      </Card>
-    </div>
-  );
-}
-
-export default function Component({ events }) {
-  const aggregateEvents = () => {
-    if (!events || events.length === 0) return null;
-    return events[events.length - 1];
-  };
-
-  const event = aggregateEvents();
-
-  return <ArtifactWorkflowCard event={event} />;
-}

packages/create-llama/templates/components/ui/use-cases/deep_research/ui_event.jsx

@@ -1,376 +0,0 @@
-import {
-  Accordion,
-  AccordionContent,
-  AccordionItem,
-  AccordionTrigger,
-} from "@/components/ui/accordion";
-import { Badge } from "@/components/ui/badge";
-import {
-  Card,
-  CardContent,
-  CardDescription,
-  CardFooter,
-  CardHeader,
-  CardTitle,
-} from "@/components/ui/card";
-import { Progress } from "@/components/ui/progress";
-import { Separator } from "@/components/ui/separator";
-import { cn } from "@/lib/utils";
-import { Markdown } from "@llamaindex/chat-ui/widgets";
-import {
-  AlertCircle,
-  Brain,
-  CheckCircle,
-  Clock,
-  Database,
-  Loader2,
-  MessageSquare,
-} from "lucide-react";
-import { useEffect, useState } from "react";
-
-export default function Component({ events }) {
-  const aggregateEvents = (events) => {
-    if (!events || events.length === 0)
-      return { retrieve: null, analyze: null, answers: [] };
-
-    // Initialize the result structure
-    const result = {
-      retrieve: null,
-      analyze: null,
-      answers: [],
-    };
-
-    // Process each event
-    events.forEach((event) => {
-      const { event: eventType, state, id, question, answer } = event;
-
-      if (eventType === "retrieve") {
-        // Update retrieve status
-        result.retrieve = { state };
-      } else if (eventType === "analyze") {
-        // Update analyze status
-        result.analyze = { state };
-      } else if (eventType === "answer" && id) {
-        // Find existing answer with the same id or create a new one
-        const existingAnswerIndex = result.answers.findIndex(
-          (a) => a.id === id,
-        );
-
-        if (existingAnswerIndex >= 0) {
-          // Update existing answer
-          result.answers[existingAnswerIndex] = {
-            ...result.answers[existingAnswerIndex],
-            state,
-            question: question || result.answers[existingAnswerIndex].question,
-            answer: answer || result.answers[existingAnswerIndex].answer,
-          };
-        } else {
-          // Add new answer
-          result.answers.push({
-            id,
-            state,
-            question,
-            answer,
-          });
-        }
-      }
-    });
-
-    return result;
-  };
-
-  const [aggregatedEvents, setAggregatedEvents] = useState({
-    retrieve: null,
-    analyze: null,
-    answers: [],
-  });
-
-  useEffect(() => {
-    setAggregatedEvents(aggregateEvents(events));
-  }, [events]);
-
-  const { retrieve, analyze, answers } = aggregatedEvents;
-
-  // Helper function to get status icon
-  const getStatusIcon = (state) => {
-    switch (state) {
-      case "pending":
-        return <Clock className="h-4 w-4 text-gray-400" />;
-      case "inprogress":
-        return <Loader2 className="h-4 w-4 animate-spin text-blue-500" />;
-      case "done":
-        return <CheckCircle className="h-4 w-4 text-green-500" />;
-      case "error":
-        return <AlertCircle className="h-4 w-4 text-red-500" />;
-      default:
-        return null;
-    }
-  };
-
-  // Helper function to get status text
-  const getStatusText = (state) => {
-    switch (state) {
-      case "pending":
-        return "Pending";
-      case "inprogress":
-        return "In Progress";
-      case "done":
-        return "Complete";
-      case "error":
-        return "Error";
-      default:
-        return "";
-    }
-  };
-
-  // Helper function to get status color class
-  const getStatusColorClass = (state) => {
-    switch (state) {
-      case "pending":
-        return "bg-gray-200";
-      case "inprogress":
-        return "bg-blue-500";
-      case "done":
-        return "bg-green-500";
-      case "error":
-        return "bg-red-500";
-      default:
-        return "bg-gray-200";
-    }
-  };
-
-  return (
-    <div className="mx-auto w-full max-w-4xl space-y-6 p-4">
-      {/* Header */}
-      <div className="mb-6 flex items-center justify-between">
-        <h1 className="text-2xl font-bold">DeepResearch Workflow</h1>
-        <div className="flex items-center space-x-2">
-          <Badge
-            variant={retrieve?.state === "done" ? "default" : "outline"}
-            className={cn(
-              "transition-all",
-              retrieve?.state === "done" ? "bg-green-500" : "",
-            )}
-          >
-            Retrieve
-          </Badge>
-          <Separator className="h-4 w-px bg-gray-300" orientation="vertical" />
-          <Badge
-            variant={analyze?.state === "done" ? "default" : "outline"}
-            className={cn(
-              "transition-all",
-              analyze?.state === "done" ? "bg-green-500" : "",
-            )}
-          >
-            Analyze
-          </Badge>
-          <Separator className="h-4 w-px bg-gray-300" orientation="vertical" />
-          <Badge
-            variant={
-              answers.length > 0 && answers.every((a) => a.state === "done")
-                ? "default"
-                : "outline"
-            }
-            className={cn(
-              "transition-all",
-              answers.length > 0 && answers.every((a) => a.state === "done")
-                ? "bg-green-500"
-                : "",
-            )}
-          >
-            Answer
-          </Badge>
-        </div>
-      </div>
-
-      {/* Retrieve Panel */}
-      <Card
-        className={cn(
-          "border-2 transition-all duration-300",
-          retrieve?.state === "inprogress"
-            ? "border-blue-500 shadow-lg shadow-blue-100"
-            : retrieve?.state === "done"
-              ? "border-green-500"
-              : retrieve?.state === "error"
-                ? "border-red-500"
-                : "border-gray-200",
-        )}
-      >
-        <CardHeader>
-          <div className="flex items-center justify-between">
-            <div className="flex items-center space-x-2">
-              <Database className="h-5 w-5 text-gray-700" />
-              <CardTitle>Retrieve Information</CardTitle>
-            </div>
-            <Badge
-              variant="outline"
-              className={cn(
-                "flex items-center space-x-1",
-                retrieve?.state === "inprogress"
-                  ? "text-blue-500"
-                  : retrieve?.state === "done"
-                    ? "text-green-500"
-                    : retrieve?.state === "error"
-                      ? "text-red-500"
-                      : "text-gray-500",
-              )}
-            >
-              {getStatusIcon(retrieve?.state)}
-              <span>{getStatusText(retrieve?.state)}</span>
-            </Badge>
-          </div>
-          <CardDescription>
-            Retrieving relevant information from the knowledge base
-          </CardDescription>
-        </CardHeader>
-      </Card>
-
-      {/* Analyze Panel */}
-      {retrieve?.state === "done" && (
-        <Card
-          className={cn(
-            "border-2 transition-all duration-300",
-            analyze?.state === "inprogress"
-              ? "border-blue-500 shadow-lg shadow-blue-100"
-              : analyze?.state === "done"
-                ? "border-green-500"
-                : analyze?.state === "error"
-                  ? "border-red-500"
-                  : "border-gray-200",
-          )}
-        >
-          <CardHeader>
-            <div className="flex items-center justify-between">
-              <div className="flex items-center space-x-2">
-                <Brain className="h-5 w-5 text-gray-700" />
-                <CardTitle>Analyze Information</CardTitle>
-              </div>
-              <Badge
-                variant="outline"
-                className={cn(
-                  "flex items-center space-x-1",
-                  analyze?.state === "inprogress"
-                    ? "text-blue-500"
-                    : analyze?.state === "done"
-                      ? "text-green-500"
-                      : analyze?.state === "error"
-                        ? "text-red-500"
-                        : "text-gray-500",
-                )}
-              >
-                {getStatusIcon(analyze?.state)}
-                <span>{getStatusText(analyze?.state)}</span>
-              </Badge>
-            </div>
-            <CardDescription>
-              Analyzing retrieved information and generating questions
-            </CardDescription>
-          </CardHeader>
-        </Card>
-      )}
-
-      {/* Answer Panel */}
-      {analyze?.state === "done" && answers.length > 0 && (
-        <Card>
-          <CardHeader>
-            <div className="flex items-center space-x-2">
-              <MessageSquare className="h-5 w-5 text-gray-700" />
-              <CardTitle>Answers</CardTitle>
-            </div>
-            <CardDescription>
-              Detailed answers to the generated questions
-            </CardDescription>
-          </CardHeader>
-          <CardContent>
-            <Accordion type="multiple" className="w-full">
-              {answers.map((answer, index) => (
-                <AccordionItem
-                  key={answer.id}
-                  value={answer.id}
-                  className={cn(
-                    "mb-4 overflow-hidden rounded-lg border",
-                    answer.state === "inprogress"
-                      ? "border-blue-500 shadow-sm shadow-blue-100"
-                      : answer.state === "done"
-                        ? "border-green-100"
-                        : answer.state === "error"
-                          ? "border-red-100"
-                          : "border-gray-200",
-                  )}
-                >
-                  <AccordionTrigger className="px-4 py-3 hover:bg-gray-50">
-                    <div className="flex items-center space-x-3 text-left">
-                      <Badge className="shrink-0 bg-gray-700 text-white">
-                        Q{index + 1}
-                      </Badge>
-                      <div className="flex-1">
-                        <p className="font-medium">{answer.question}</p>
-                      </div>
-                      <Badge
-                        variant="outline"
-                        className={cn(
-                          "ml-auto flex shrink-0 items-center space-x-1",
-                          answer.state === "inprogress"
-                            ? "text-blue-500"
-                            : answer.state === "done"
-                              ? "text-green-500"
-                              : answer.state === "error"
-                                ? "text-red-500"
-                                : "text-gray-500",
-                        )}
-                      >
-                        {getStatusIcon(answer.state)}
-                        <span>{getStatusText(answer.state)}</span>
-                      </Badge>
-                    </div>
-                  </AccordionTrigger>
-                  <AccordionContent className="px-4 pb-4 pt-1">
-                    <div
-                      className={cn(
-                        "rounded-md p-3",
-                        answer.state === "done"
-                          ? "bg-green-50"
-                          : answer.state === "inprogress"
-                            ? "bg-blue-50"
-                            : "bg-gray-50",
-                      )}
-                    >
-                      {answer.answer ? (
-                        <Markdown content={answer.answer} />
-                      ) : (
-                        <div className="flex items-center justify-center p-4 text-gray-500">
-                          {answer.state === "inprogress" ? (
-                            <div className="flex items-center space-x-2">
-                              <Loader2 className="h-4 w-4 animate-spin" />
-                              <span>Generating answer...</span>
-                            </div>
-                          ) : (
-                            <span>Waiting for answer</span>
-                          )}
-                        </div>
-                      )}
-                    </div>
-                  </AccordionContent>
-                </AccordionItem>
-              ))}
-            </Accordion>
-          </CardContent>
-          <CardFooter className="flex justify-between">
-            <div className="text-sm text-gray-500">
-              {answers.filter((a) => a.state === "done").length} of{" "}
-              {answers.length} questions answered
-            </div>
-            <Progress
-              value={
-                (answers.filter((a) => a.state === "done").length /
-                  answers.length) *
-                100
-              }
-              className="h-2 w-1/3 bg-gray-200"
-            />
-          </CardFooter>
-        </Card>
-      )}
-    </div>
-  );
-}

packages/create-llama/templates/components/ui/use-cases/document_generator/ui_event.jsx

@@ -1,132 +0,0 @@
-import { Badge } from "@/components/ui/badge";
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
-import { Progress } from "@/components/ui/progress";
-import { Skeleton } from "@/components/ui/skeleton";
-import { cn } from "@/lib/utils";
-import { Markdown } from "@llamaindex/chat-ui/widgets";
-import { ListChecks, Loader2, Wand2 } from "lucide-react";
-import { useEffect, useState } from "react";
-
-const STAGE_META = {
-  plan: {
-    icon: ListChecks,
-    badgeText: "Step 1/2: Planning",
-    gradient: "from-blue-100 via-blue-50 to-white",
-    progress: 33,
-    iconBg: "bg-blue-100 text-blue-600",
-    badge: "bg-blue-100 text-blue-700",
-  },
-  generate: {
-    icon: Wand2,
-    badgeText: "Step 2/2: Generating",
-    gradient: "from-violet-100 via-violet-50 to-white",
-    progress: 66,
-    iconBg: "bg-violet-100 text-violet-600",
-    badge: "bg-violet-100 text-violet-700",
-  },
-};
-
-function ArtifactWorkflowCard({ event }) {
-  const [visible, setVisible] = useState(event?.state !== "completed");
-  const [fade, setFade] = useState(false);
-
-  useEffect(() => {
-    if (event?.state === "completed") {
-      setVisible(false);
-    } else {
-      setVisible(true);
-      setFade(false);
-    }
-  }, [event?.state]);
-
-  if (!event || !visible) return null;
-
-  const { state, requirement } = event;
-  const meta = STAGE_META[state];
-
-  if (!meta) return null;
-
-  return (
-    <div className="flex min-h-[180px] w-full items-center justify-center py-2">
-      <Card
-        className={cn(
-          "w-full rounded-xl shadow-md transition-all duration-500",
-          "border-0",
-          fade && "pointer-events-none opacity-0",
-          `bg-gradient-to-br ${meta.gradient}`,
-        )}
-        style={{
-          boxShadow:
-            "0 2px 12px 0 rgba(80, 80, 120, 0.08), 0 1px 3px 0 rgba(80, 80, 120, 0.04)",
-        }}
-      >
-        <CardHeader className="flex flex-row items-center gap-2 px-3 pb-1 pt-2">
-          <div
-            className={cn(
-              "flex items-center justify-center rounded-full p-1",
-              meta.iconBg,
-            )}
-          >
-            <meta.icon className="h-5 w-5" />
-          </div>
-          <CardTitle className="flex items-center gap-2 text-base font-semibold">
-            <Badge className={cn("ml-1", meta.badge, "px-2 py-0.5 text-xs")}>
-              {meta.badgeText}
-            </Badge>
-          </CardTitle>
-        </CardHeader>
-        <CardContent className="px-3 py-1">
-          {state === "plan" && (
-            <div className="flex flex-col items-center gap-2 py-2">
-              <Loader2 className="mb-1 h-6 w-6 animate-spin text-blue-400" />
-              <div className="text-center text-sm font-medium text-blue-900">
-                Analyzing your request...
-              </div>
-              <Skeleton className="mt-1 h-3 w-1/2 rounded-full" />
-            </div>
-          )}
-          {state === "generate" && (
-            <div className="flex flex-col gap-2 py-2">
-              <div className="flex items-center gap-1">
-                <Loader2 className="h-4 w-4 animate-spin text-violet-400" />
-                <span className="text-sm font-medium text-violet-900">
-                  Working on the requirement:
-                </span>
-              </div>
-              <div className="max-h-24 overflow-auto rounded-lg border border-violet-200 bg-violet-50 px-2 py-1 text-xs">
-                {requirement ? (
-                  <Markdown content={requirement} />
-                ) : (
-                  <span className="italic text-violet-400">
-                    No requirements available yet.
-                  </span>
-                )}
-              </div>
-            </div>
-          )}
-        </CardContent>
-        <div className="px-3 pb-2 pt-1">
-          <Progress
-            value={meta.progress}
-            className={cn(
-              "h-1 rounded-full bg-gray-200",
-              state === "plan" && "bg-blue-200",
-              state === "generate" && "bg-violet-200",
-            )}
-          />
-        </div>
-      </Card>
-    </div>
-  );
-}
-
-export default function Component({ events }) {
-  const aggregateEvents = () => {
-    if (!events || events.length === 0) return null;
-    return events[events.length - 1];
-  };
-
-  const event = aggregateEvents();
-
-  return <ArtifactWorkflowCard event={event} />;
-}

packages/create-llama/templates/components/use-cases/python/agentic_rag/README-template.md

@@ -1,59 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) simple agentic RAG project using [Agent Workflows](https://docs.llamaindex.ai/en/stable/examples/agent/agent_workflow_basic/).
-
-## Getting Started
-
-First, setup the environment with uv:
-
-> **_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.
-Make sure you have set the `OPENAI_API_KEY` for the LLM.
-
-Second, generate the embeddings of the documents in the `./data` directory:
-
-```shell
-uv run generate
-```
-
-Third, run the development server:
-
-```shell
-uv run fastapi dev
-```
-
-Then open [http://localhost:8000](http://localhost:8000) with your browser to start the chat UI.
-
-To start the app optimized for **production**, run:
-
-```
-uv run fastapi run
-```
-
-## Configure LLM and Embedding Model
-
-You can configure [LLM model](https://docs.llamaindex.ai/en/stable/module_guides/models/llms) and [embedding model](https://docs.llamaindex.ai/en/stable/module_guides/models/embeddings) in [settings.py](app/settings.py).
-
-## Use Case
-
-We have prepared an [example workflow](./app/workflow.py) for the agentic RAG use case, where you can ask questions about the example documents in the [./data](./data) directory.
-
-You can start by sending an request on the [chat UI](http://localhost:8000) or you can test the `/api/chat` endpoint with the following curl request:
-
-```
-curl --location 'localhost:8000/api/chat' \
---header 'Content-Type: application/json' \
---data '{ "messages": [{ "role": "user", "content": "What standards for a letter exist?" }] }'
-```
-
-## 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/use-cases/python/agentic_rag/workflow.py

@@ -1,22 +0,0 @@
-from typing import Optional
-
-from app.index import get_index
-from llama_index.core.agent.workflow import AgentWorkflow
-from llama_index.core.settings import Settings
-from llama_index.llms.openai import OpenAI
-from llama_index.server.api.models import ChatRequest
-from llama_index.server.tools.index import get_query_engine_tool
-
-
-def create_workflow(chat_request: Optional[ChatRequest] = None) -> AgentWorkflow:
-    index = get_index(chat_request=chat_request)
-    if index is None:
-        raise RuntimeError(
-            "Index not found! Please run `uv run generate` to index the data first."
-        )
-    query_tool = get_query_engine_tool(index=index)
-    return AgentWorkflow.from_tools_or_functions(
-        tools_or_functions=[query_tool],
-        llm=Settings.llm or OpenAI(model="gpt-4o-mini"),
-        system_prompt="You are a helpful assistant.",
-    )

packages/create-llama/templates/components/use-cases/python/code_generator/README-template.md

@@ -1,65 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) project using [Workflows](https://docs.llamaindex.ai/en/stable/understanding/workflows/).
-
-## Getting Started
-
-First, setup the environment with uv:
-
-> **_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.
-Make sure you have set the `OPENAI_API_KEY` for the LLM.
-
-Then, run the development server:
-
-```shell
-uv run fastapi dev
-```
-
-Then open [http://localhost:8000](http://localhost:8000) with your browser to start the chat UI.
-
-To start the app optimized for **production**, run:
-
-```
-uv run fastapi run
-```
-
-## Configure LLM and Embedding Model
-
-You can configure [LLM model](https://docs.llamaindex.ai/en/stable/module_guides/models/llms) and [embedding model](https://docs.llamaindex.ai/en/stable/module_guides/models/embeddings) in [settings.py](app/settings.py).
-
-## Use Case
-AI-powered code generator that can help you generate app with a chat interface, code editor and app preview.
-
-To update the workflow, you can modify the code in [`workflow.py`](app/workflow.py).
-
-You can start by sending an request on the [chat UI](http://localhost:8000) or you can test the `/api/chat` endpoint with the following curl request:
-
-```
-curl --location 'localhost:8000/api/chat' \
---header 'Content-Type: application/json' \
---data '{ "messages": [{ "role": "user", "content": "Create a report comparing the finances of Apple and Tesla" }] }'
-```
-
-## Customize the UI
-
-To customize the UI, you can start by modifying the [./components/ui_event.jsx](./components/ui_event.jsx) file.
-
-You can also generate a new code for the workflow using LLM by running the following command:
-
-```
-uv run generate_ui
-```
-
-## 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.
-- [LlamaIndex Server](https://pypi.org/project/llama-index-server/)
-
-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/use-cases/python/code_generator/workflow.py

@@ -1,375 +0,0 @@
-import re
-import time
-from typing import Any, Literal, Optional, Union
-
-from llama_index.core.chat_engine.types import ChatMessage
-from llama_index.core.llms import LLM
-from llama_index.core.memory import ChatMemoryBuffer
-from llama_index.core.prompts import PromptTemplate
-from llama_index.llms.openai import OpenAI
-from llama_index.core.workflow import (
-    Context,
-    Event,
-    StartEvent,
-    StopEvent,
-    Workflow,
-    step,
-)
-from llama_index.server.api.models import (
-    Artifact,
-    ArtifactEvent,
-    ArtifactType,
-    ChatRequest,
-    CodeArtifactData,
-    UIEvent,
-)
-from llama_index.server.api.utils import get_last_artifact
-from pydantic import BaseModel, Field
-
-
-def create_workflow(chat_request: ChatRequest) -> Workflow:
-    workflow = CodeArtifactWorkflow(
-        llm=OpenAI(model="gpt-4.1"),
-        chat_request=chat_request,
-        timeout=120.0,
-    )
-    return workflow
-
-
-class Requirement(BaseModel):
-    next_step: Literal["answering", "coding"]
-    language: Optional[str] = None
-    file_name: Optional[str] = None
-    requirement: str
-
-
-class PlanEvent(Event):
-    user_msg: str
-    context: Optional[str] = None
-
-
-class GenerateArtifactEvent(Event):
-    requirement: Requirement
-
-
-class SynthesizeAnswerEvent(Event):
-    pass
-
-
-class UIEventData(BaseModel):
-    """
-    Event data for updating workflow status to the UI.
-    """
-
-    state: Literal["plan", "generate", "completed"] = Field(
-        description="The current state of the workflow. "
-        "plan: analyze and create a plan for the next step. "
-        "generate: generate the artifact based on the requirement from the previous step. "
-        "completed: the workflow is completed. "
-    )
-    requirement: Optional[str] = Field(
-        description="The requirement for generating the artifact. ",
-        default=None,
-    )
-
-
-class CodeArtifactWorkflow(Workflow):
-    """
-    A simple workflow that help generate/update the chat artifact (code, document)
-    e.g: Help create a NextJS app.
-         Update the generated code with the user's feedback.
-         Generate a guideline for the app,...
-    """
-
-    def __init__(
-        self,
-        llm: LLM,
-        chat_request: ChatRequest,
-        **kwargs: Any,
-    ):
-        """
-        Args:
-            llm: The LLM to use.
-            chat_request: The chat request from the chat app to use.
-        """
-        super().__init__(**kwargs)
-        self.llm = llm
-        self.chat_request = chat_request
-        self.last_artifact = get_last_artifact(chat_request)
-
-    @step
-    async def prepare_chat_history(self, ctx: Context, ev: StartEvent) -> PlanEvent:
-        user_msg = ev.user_msg
-        if user_msg is None:
-            raise ValueError("user_msg is required to run the workflow")
-        await ctx.set("user_msg", user_msg)
-        chat_history = ev.chat_history or []
-        chat_history.append(
-            ChatMessage(
-                role="user",
-                content=user_msg,
-            )
-        )
-        memory = ChatMemoryBuffer.from_defaults(
-            chat_history=chat_history,
-            llm=self.llm,
-        )
-        await ctx.set("memory", memory)
-        return PlanEvent(
-            user_msg=user_msg,
-            context=str(self.last_artifact.model_dump_json())
-            if self.last_artifact
-            else "",
-        )
-
-    @step
-    async def planning(
-        self, ctx: Context, event: PlanEvent
-    ) -> Union[GenerateArtifactEvent, SynthesizeAnswerEvent]:
-        """
-        Based on the conversation history and the user's request
-        this step will help to provide a good next step for the code or document generation.
-        """
-        ctx.write_event_to_stream(
-            UIEvent(
-                type="ui_event",
-                data=UIEventData(
-                    state="plan",
-                    requirement=None,
-                ),
-            )
-        )
-        prompt = PromptTemplate("""
-        You are a product analyst responsible for analyzing the user's request and providing the next step for code or document generation.
-        You are helping user with their code artifact. To update the code, you need to plan a coding step.
-    
-        Follow these instructions:
-        1. Carefully analyze the conversation history and the user's request to determine what has been done and what the next step should be.
-        2. The next step must be one of the following two options:
-           - "coding": To make the changes to the current code.
-           - "answering": If you don't need to update the current code or need clarification from the user.
-        Important: Avoid telling the user to update the code themselves, you are the one who will update the code (by planning a coding step).
-        3. If the next step is "coding", you may specify the language ("typescript" or "python") and file_name if known, otherwise set them to null. 
-        4. The requirement must be provided clearly what is the user request and what need to be done for the next step in details
-           as precise and specific as possible, don't be stingy with in the requirement.
-        5. If the next step is "answering", set language and file_name to null, and the requirement should describe what to answer or explain to the user.
-        6. Be concise; only return the requirements for the next step.
-        7. The requirements must be in the following format:
-           ```json
-           {
-               "next_step": "answering" | "coding",
-               "language": "typescript" | "python" | null,
-               "file_name": string | null,
-               "requirement": string
-           }
-           ```
-
-        ## Example 1:
-        User request: Create a calculator app.
-        You should return:
-        ```json
-        {
-            "next_step": "coding",
-            "language": "typescript",
-            "file_name": "calculator.tsx",
-            "requirement": "Generate code for a calculator app that has a simple UI with a display and button layout. The display should show the current input and the result. The buttons should include basic operators, numbers, clear, and equals. The calculation should work correctly."
-        }
-        ```
-
-        ## Example 2:
-        User request: Explain how the game loop works.
-        Context: You have already generated the code for a snake game.
-        You should return:
-        ```json
-        {
-            "next_step": "answering",
-            "language": null,
-            "file_name": null,
-            "requirement": "The user is asking about the game loop. Explain how the game loop works."
-        }
-        ```
-
-        {context}
-
-        Now, plan the user's next step for this request:
-        {user_msg}
-        """).format(
-            context=""
-            if event.context is None
-            else f"## The context is: \n{event.context}\n",
-            user_msg=event.user_msg,
-        )
-        response = await self.llm.acomplete(
-            prompt=prompt,
-            formatted=True,
-        )
-        # parse the response to Requirement
-        # 1. use regex to find the json block
-        json_block = re.search(
-            r"```(?:json)?\s*([\s\S]*?)\s*```", response.text, re.IGNORECASE
-        )
-        if json_block is None:
-            raise ValueError("No JSON block found in the response.")
-        # 2. parse the json block to Requirement
-        requirement = Requirement.model_validate_json(json_block.group(1).strip())
-        ctx.write_event_to_stream(
-            UIEvent(
-                type="ui_event",
-                data=UIEventData(
-                    state="generate",
-                    requirement=requirement.requirement,
-                ),
-            )
-        )
-        # Put the planning result to the memory
-        # useful for answering step
-        memory: ChatMemoryBuffer = await ctx.get("memory")
-        memory.put(
-            ChatMessage(
-                role="assistant",
-                content=f"The plan for next step: \n{response.text}",
-            )
-        )
-        await ctx.set("memory", memory)
-        if requirement.next_step == "coding":
-            return GenerateArtifactEvent(
-                requirement=requirement,
-            )
-        else:
-            return SynthesizeAnswerEvent()
-
-    @step
-    async def generate_artifact(
-        self, ctx: Context, event: GenerateArtifactEvent
-    ) -> SynthesizeAnswerEvent:
-        """
-        Generate the code based on the user's request.
-        """
-        ctx.write_event_to_stream(
-            UIEvent(
-                type="ui_event",
-                data=UIEventData(
-                    state="generate",
-                    requirement=event.requirement.requirement,
-                ),
-            )
-        )
-        prompt = PromptTemplate("""
-         You are a skilled developer who can help user with coding.
-         You are given a task to generate or update a code for a given requirement.
-
-         ## Follow these instructions:
-         **1. Carefully read the user's requirements.** 
-            If any details are ambiguous or missing, make reasonable assumptions and clearly reflect those in your output.
-            If the previous code is provided:
-            + Carefully analyze the code with the request to make the right changes.
-            + Avoid making a lot of changes from the previous code if the request is not to write the code from scratch again.
-         **2. For code requests:**
-            - If the user does not specify a framework or language, default to a React component using the Next.js framework.
-            - For Next.js, use Shadcn UI components, Typescript, @types/node, @types/react, @types/react-dom, PostCSS, and TailwindCSS.
-            The import pattern should be:
-            ```
-            import { ComponentName } from "@/components/ui/component-name"
-            import { Markdown } from "@llamaindex/chat-ui"
-            import { cn } from "@/lib/utils"
-            ```
-            - Ensure the code is idiomatic, production-ready, and includes necessary imports.
-            - Only generate code relevant to the user's request—do not add extra boilerplate.
-         **3. Don't be verbose on response**
-            - No other text or comments only return the code which wrapped by ```language``` block.
-            - If the user's request is to update the code, only return the updated code.
-         **4. Only the following languages are allowed: "typescript", "python".**
-         **5. If there is no code to update, return the reason without any code block.**
-            
-         ## Example:
-         ```typescript
-         import React from "react";
-         import { Button } from "@/components/ui/button";
-         import { cn } from "@/lib/utils";
-
-         export default function MyComponent() {
-         return (
-            <div className="flex flex-col items-center justify-center h-screen">
-               <Button>Click me</Button>
-            </div>
-         );
-         }
-
-         The previous code is:
-         {previous_artifact}
-
-         Now, i have to generate the code for the following requirement:
-         {requirement}
-         ```
-        """).format(
-            previous_artifact=self.last_artifact.model_dump_json()
-            if self.last_artifact
-            else "",
-            requirement=event.requirement,
-        )
-        response = await self.llm.acomplete(
-            prompt=prompt,
-            formatted=True,
-        )
-        # Extract the code from the response
-        language_pattern = r"```(\w+)([\s\S]*)```"
-        code_match = re.search(language_pattern, response.text)
-        if code_match is None:
-            return SynthesizeAnswerEvent()
-        else:
-            code = code_match.group(2).strip()
-        # Put the generated code to the memory
-        memory: ChatMemoryBuffer = await ctx.get("memory")
-        memory.put(
-            ChatMessage(
-                role="assistant",
-                content=f"Updated the code: \n{response.text}",
-            )
-        )
-        # To show the Canvas panel for the artifact
-        ctx.write_event_to_stream(
-            ArtifactEvent(
-                data=Artifact(
-                    type=ArtifactType.CODE,
-                    created_at=int(time.time()),
-                    data=CodeArtifactData(
-                        language=event.requirement.language or "",
-                        file_name=event.requirement.file_name or "",
-                        code=code,
-                    ),
-                ),
-            )
-        )
-        return SynthesizeAnswerEvent()
-
-    @step
-    async def synthesize_answer(
-        self, ctx: Context, event: SynthesizeAnswerEvent
-    ) -> StopEvent:
-        """
-        Synthesize the answer.
-        """
-        memory: ChatMemoryBuffer = await ctx.get("memory")
-        chat_history = memory.get()
-        chat_history.append(
-            ChatMessage(
-                role="system",
-                content="""
-                You are a helpful assistant who is responsible for explaining the work to the user.
-                Based on the conversation history, provide an answer to the user's question. 
-                The user has access to the code so avoid mentioning the whole code again in your response.
-                """,
-            )
-        )
-        response_stream = await self.llm.astream_chat(
-            messages=chat_history,
-        )
-        ctx.write_event_to_stream(
-            UIEvent(
-                type="ui_event",
-                data=UIEventData(
-                    state="completed",
-                ),
-            )
-        )
-        return StopEvent(result=response_stream)

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

@@ -1,69 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) multi-agents project using [Workflows](https://docs.llamaindex.ai/en/stable/understanding/workflows/).
-
-## Getting Started
-
-First, setup the environment with uv:
-
-> **_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.
-Make sure you have set the `OPENAI_API_KEY` for the LLM.
-
-Second, generate the embeddings of the documents in the `./data` directory:
-
-```shell
-uv run generate
-```
-
-Third, run the development server:
-
-```shell
-uv run fastapi dev
-```
-
-Then open [http://localhost:8000](http://localhost:8000) with your browser to start the chat UI.
-
-To start the app optimized for **production**, run:
-
-```
-uv run fastapi run
-```
-
-## Configure LLM and Embedding Model
-
-You can configure [LLM model](https://docs.llamaindex.ai/en/stable/module_guides/models/llms) and [embedding model](https://docs.llamaindex.ai/en/stable/module_guides/models/embeddings) in [settings.py](app/settings.py).
-
-## Use Case
-
-We have prepared an [example workflow](./app/workflow.py) for the deep research use case, where you can ask questions about the example documents in the [./data](./data) directory.
-
-You can start by sending an request on the [chat UI](http://localhost:8000) or you can test the `/api/chat` endpoint with the following curl request:
-
-```
-curl --location 'localhost:8000/api/chat' \
---header 'Content-Type: application/json' \
---data '{ "messages": [{ "role": "user", "content": "Create a report comparing the finances of Apple and Tesla" }] }'
-```
-
-## Customize the UI
-
-To customize the UI, you can start by modifying the [./components/ui_event.jsx](./components/ui_event.jsx) file.
-
-You can also generate a new code for the workflow using LLM by running the following command:
-
-```
-uv run generate_ui
-```
-
-## 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/use-cases/python/deep_research/workflow.py

@@ -1,542 +0,0 @@
-import logging
-import os
-import uuid
-from typing import List, Literal, Optional
-
-from app.index import get_index
-from llama_index.core.base.llms.types import (
-    CompletionResponse,
-    CompletionResponseAsyncGen,
-)
-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.prompts import PromptTemplate
-from llama_index.core.schema import MetadataMode, Node, NodeWithScore
-from llama_index.core.settings import Settings
-from llama_index.core.types import ChatMessage, MessageRole
-from llama_index.core.workflow import (
-    Context,
-    Event,
-    StartEvent,
-    StopEvent,
-    Workflow,
-    step,
-)
-from llama_index.server.api.models import ChatRequest, SourceNodesEvent, UIEvent
-from pydantic import BaseModel, Field
-
-logger = logging.getLogger("uvicorn")
-logger.setLevel(logging.INFO)
-
-
-def create_workflow(chat_request: Optional[ChatRequest] = None) -> Workflow:
-    index = get_index(chat_request=chat_request)
-    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,
-    )
-
-
-# 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 UIEventData(BaseModel):
-    """
-    Events for DeepResearch workflow which has 3 main stages:
-    - Retrieve: Retrieve information from the knowledge base.
-    - Analyze: Analyze the retrieved information and provide list of questions for answering.
-    - Answer: Answering the provided questions. There are multiple answer events, each with its own id that is used to display the answer for a particular question.
-    """
-
-    id: Optional[str] = Field(default=None, description="The id of the event")
-    event: Literal["retrieve", "analyze", "answer"] = Field(
-        default="retrieve", description="The event type"
-    )
-    state: Literal["pending", "inprogress", "done", "error"] = Field(
-        default="pending", description="The state of the event"
-    )
-    question: Optional[str] = Field(
-        default=None,
-        description="Used by answer event to display the question",
-    )
-    answer: Optional[str] = Field(
-        default=None,
-        description="Used by answer event to display the answer of the question",
-    )
-
-
-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(
-            UIEvent(
-                type="ui_event",
-                data=UIEventData(
-                    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)  # type: ignore
-        ctx.write_event_to_stream(
-            UIEvent(
-                type="ui_event",
-                data=UIEventData(
-                    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(
-            UIEvent(
-                type="ui_event",
-                data=UIEventData(
-                    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(
-                UIEvent(
-                    type="ui_event",
-                    data=UIEventData(
-                        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(
-                    UIEvent(
-                        type="ui_event",
-                        data=UIEventData(
-                            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(
-                    UIEvent(
-                        type="ui_event",
-                        data=UIEventData(
-                            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(
-            UIEvent(
-                type="ui_event",
-                data=UIEventData(
-                    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(
-            UIEvent(
-                type="ui_event",
-                data=UIEventData(
-                    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(
-            UIEvent(
-                type="ui_event",
-                data=UIEventData(
-                    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,
-        )
-
-
-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/use-cases/python/document_generator/README-template.md

@@ -1,66 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) project using [Workflows](https://docs.llamaindex.ai/en/stable/understanding/workflows/).
-
-## Getting Started
-
-First, setup the environment with uv:
-
-> **_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.
-Make sure you have set the `OPENAI_API_KEY` for the LLM.
-
-Then, run the development server:
-
-```shell
-uv run fastapi dev
-```
-
-Then open [http://localhost:8000](http://localhost:8000) with your browser to start the chat UI.
-
-To start the app optimized for **production**, run:
-
-```
-uv run fastapi run
-```
-
-## Configure LLM and Embedding Model
-
-You can configure [LLM model](https://docs.llamaindex.ai/en/stable/module_guides/models/llms) and [embedding model](https://docs.llamaindex.ai/en/stable/module_guides/models/embeddings) in [settings.py](app/settings.py).
-
-## Use Case
-
-AI-powered document generator that can help you generate documents with a chat interface and simple markdown editor.
-
-To update the workflow, you can modify the code in [`workflow.py`](app/workflow.py).
-
-You can start by sending an request on the [chat UI](http://localhost:8000) or you can test the `/api/chat` endpoint with the following curl request:
-
-```
-curl --location 'localhost:8000/api/chat' \
---header 'Content-Type: application/json' \
---data '{ "messages": [{ "role": "user", "content": "Create a report comparing the finances of Apple and Tesla" }] }'
-```
-
-## Customize the UI
-
-To customize the UI, you can start by modifying the [./components/ui_event.jsx](./components/ui_event.jsx) file.
-
-You can also generate a new code for the workflow using LLM by running the following command:
-
-```
-uv run generate_ui
-```
-
-## 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.
-- [LlamaIndex Server](https://pypi.org/project/llama-index-server/)
-
-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/use-cases/python/document_generator/workflow.py

@@ -1,347 +0,0 @@
-import re
-import time
-from typing import Any, Literal, Optional
-
-from llama_index.core.chat_engine.types import ChatMessage
-from llama_index.core.llms import LLM
-from llama_index.llms.openai import OpenAI
-from llama_index.core.memory import ChatMemoryBuffer
-from llama_index.core.prompts import PromptTemplate
-from llama_index.core.workflow import (
-    Context,
-    Event,
-    StartEvent,
-    StopEvent,
-    Workflow,
-    step,
-)
-from llama_index.server.api.models import (
-    Artifact,
-    ArtifactEvent,
-    ArtifactType,
-    ChatRequest,
-    DocumentArtifactData,
-    UIEvent,
-)
-from llama_index.server.api.utils import get_last_artifact
-from pydantic import BaseModel, Field
-
-
-def create_workflow(chat_request: ChatRequest) -> Workflow:
-    workflow = DocumentArtifactWorkflow(
-        llm=OpenAI(model="gpt-4.1"),
-        chat_request=chat_request,
-        timeout=120.0,
-    )
-    return workflow
-
-
-class DocumentRequirement(BaseModel):
-    type: Literal["markdown", "html"]
-    title: str
-    requirement: str
-
-
-class PlanEvent(Event):
-    user_msg: str
-    context: Optional[str] = None
-
-
-class GenerateArtifactEvent(Event):
-    requirement: DocumentRequirement
-
-
-class SynthesizeAnswerEvent(Event):
-    requirement: DocumentRequirement
-    generated_artifact: str
-
-
-class UIEventData(BaseModel):
-    """
-    Event data for updating workflow status to the UI.
-    """
-
-    state: Literal["plan", "generate", "completed"] = Field(
-        description="The current state of the workflow. "
-        "plan: analyze and create a plan for the next step. "
-        "generate: generate the artifact based on the requirement from the previous step. "
-        "completed: the workflow is completed. "
-    )
-    requirement: Optional[str] = Field(
-        description="The requirement for generating the artifact. ",
-        default=None,
-    )
-
-
-class DocumentArtifactWorkflow(Workflow):
-    """
-    A workflow to help generate or update document artifacts (e.g., Markdown or HTML documents).
-    Example use cases: Generate a project guideline, update documentation with user feedback, etc.
-    """
-
-    def __init__(
-        self,
-        llm: LLM,
-        chat_request: ChatRequest,
-        **kwargs: Any,
-    ):
-        """
-        Args:
-            llm: The LLM to use.
-            chat_request: The chat request from the chat app to use.
-        """
-        super().__init__(**kwargs)
-        self.llm = llm
-        self.chat_request = chat_request
-        self.last_artifact = get_last_artifact(chat_request)
-
-    @step
-    async def prepare_chat_history(self, ctx: Context, ev: StartEvent) -> PlanEvent:
-        user_msg = ev.user_msg
-        if user_msg is None:
-            raise ValueError("user_msg is required to run the workflow")
-        await ctx.set("user_msg", user_msg)
-        chat_history = ev.chat_history or []
-        chat_history.append(
-            ChatMessage(
-                role="user",
-                content=user_msg,
-            )
-        )
-        memory = ChatMemoryBuffer.from_defaults(
-            chat_history=chat_history,
-            llm=self.llm,
-        )
-        await ctx.set("memory", memory)
-        return PlanEvent(
-            user_msg=user_msg,
-            context=str(self.last_artifact.model_dump_json())
-            if self.last_artifact
-            else "",
-        )
-
-    @step
-    async def planning(self, ctx: Context, event: PlanEvent) -> GenerateArtifactEvent:
-        """
-        Based on the conversation history and the user's request,
-        this step will provide a clear requirement for the next document generation or update.
-        """
-        ctx.write_event_to_stream(
-            UIEvent(
-                type="ui_event",
-                data=UIEventData(
-                    state="plan",
-                    requirement=None,
-                ),
-            )
-        )
-        prompt = PromptTemplate("""
-         You are a documentation analyst responsible for analyzing the user's request and providing requirements for document generation or update.
-         Follow these instructions:
-         1. Carefully analyze the conversation history and the user's request to determine what has been done and what the next step should be.
-         2. From the user's request, provide requirements for the next step of the document generation or update.
-         3. Do not be verbose; only return the requirements for the next step of the document generation or update.
-         4. Only the following document types are allowed: "markdown", "html".
-         5. The requirement should be in the following format:
-            ```json
-            {
-                "type": "markdown" | "html",
-                "title": string,
-                "requirement": string
-            }
-            ```
-
-         ## Example:
-         User request: Create a project guideline document.
-         You should return:
-         ```json
-         {
-             "type": "markdown",
-             "title": "Project Guideline",
-             "requirement": "Generate a Markdown document that outlines the project goals, deliverables, and timeline. Include sections for introduction, objectives, deliverables, and timeline."
-         }
-         ```
-
-         User request: Add a troubleshooting section to the guideline.
-         You should return:
-         ```json
-         {
-             "type": "markdown",
-             "title": "Project Guideline",
-             "requirement": "Add a 'Troubleshooting' section at the end of the document with common issues and solutions."
-         }
-         ```
-
-         {context}
-
-         Now, please plan for the user's request:
-         {user_msg}
-        """).format(
-            context=""
-            if event.context is None
-            else f"## The context is: \n{event.context}\n",
-            user_msg=event.user_msg,
-        )
-        response = await self.llm.acomplete(
-            prompt=prompt,
-            formatted=True,
-        )
-        # parse the response to DocumentRequirement
-        json_block = re.search(r"```json([\s\S]*)```", response.text)
-        if json_block is None:
-            raise ValueError("No json block found in the response")
-        requirement = DocumentRequirement.model_validate_json(
-            json_block.group(1).strip()
-        )
-
-        # Put the planning result to the memory
-        memory: ChatMemoryBuffer = await ctx.get("memory")
-        memory.put(
-            ChatMessage(
-                role="assistant",
-                content=f"Planning for the document generation: \n{response.text}",
-            )
-        )
-        await ctx.set("memory", memory)
-        ctx.write_event_to_stream(
-            UIEvent(
-                type="ui_event",
-                data=UIEventData(
-                    state="generate",
-                    requirement=requirement.requirement,
-                ),
-            )
-        )
-        return GenerateArtifactEvent(
-            requirement=requirement,
-        )
-
-    @step
-    async def generate_artifact(
-        self, ctx: Context, event: GenerateArtifactEvent
-    ) -> SynthesizeAnswerEvent:
-        """
-        Generate or update the document based on the user's request.
-        """
-        ctx.write_event_to_stream(
-            UIEvent(
-                type="ui_event",
-                data=UIEventData(
-                    state="generate",
-                    requirement=event.requirement.requirement,
-                ),
-            )
-        )
-        prompt = PromptTemplate("""
-         You are a skilled technical writer who can help users with documentation.
-         You are given a task to generate or update a document for a given requirement.
-
-         ## Follow these instructions:
-         **1. Carefully read the user's requirements.**
-            If any details are ambiguous or missing, make reasonable assumptions and clearly reflect those in your output.
-            If the previous document is provided:
-            + Carefully analyze the document with the request to make the right changes.
-            + Avoid making unnecessary changes from the previous document if the request is not to rewrite it from scratch.
-         **2. For document requests:**
-            - If the user does not specify a type, default to Markdown.
-            - Ensure the document is clear, well-structured, and grammatically correct.
-            - Only generate content relevant to the user's request—do not add extra boilerplate.
-         **3. Do not be verbose in your response.**
-            - No other text or comments; only return the document content wrapped by the appropriate code block (```markdown or ```html).
-            - If the user's request is to update the document, only return the updated document.
-         **4. Only the following types are allowed: "markdown", "html".**
-         **5. If there is no change to the document, return the reason without any code block.**
-
-         ## Example:
-         ```markdown
-         # Project Guideline
-         
-         ## Introduction
-         ...
-         ```
-
-         The previous content is:
-         {previous_artifact}
-
-         Now, please generate the document for the following requirement:
-         {requirement}
-         """).format(
-            previous_artifact=self.last_artifact.model_dump_json()
-            if self.last_artifact
-            else "",
-            requirement=event.requirement,
-        )
-        response = await self.llm.acomplete(
-            prompt=prompt,
-            formatted=True,
-        )
-        # Extract the document from the response
-        language_pattern = r"```(markdown|html)([\s\S]*)```"
-        doc_match = re.search(language_pattern, response.text)
-        if doc_match is None:
-            return SynthesizeAnswerEvent(
-                requirement=event.requirement,
-                generated_artifact="There is no change to the document. "
-                + response.text.strip(),
-            )
-        content = doc_match.group(2).strip()
-        doc_type = doc_match.group(1)
-        # Put the generated document to the memory
-        memory: ChatMemoryBuffer = await ctx.get("memory")
-        memory.put(
-            ChatMessage(
-                role="assistant",
-                content=f"Generated document: \n{response.text}",
-            )
-        )
-        # To show the Canvas panel for the artifact
-        ctx.write_event_to_stream(
-            ArtifactEvent(
-                data=Artifact(
-                    type=ArtifactType.DOCUMENT,
-                    created_at=int(time.time()),
-                    data=DocumentArtifactData(
-                        title=event.requirement.title,
-                        content=content,
-                        type=doc_type,  # type: ignore
-                    ),
-                ),
-            )
-        )
-        return SynthesizeAnswerEvent(
-            requirement=event.requirement,
-            generated_artifact=response.text,
-        )
-
-    @step
-    async def synthesize_answer(
-        self, ctx: Context, event: SynthesizeAnswerEvent
-    ) -> StopEvent:
-        """
-        Synthesize the answer for the user.
-        """
-        memory: ChatMemoryBuffer = await ctx.get("memory")
-        chat_history = memory.get()
-        chat_history.append(
-            ChatMessage(
-                role="system",
-                content="""
-                Your responsibility is to explain the work to the user.
-                If there is no document to update, explain the reason.
-                If the document is updated, just summarize what changed. Don't need to include the whole document again in the response.
-                """,
-            )
-        )
-        response_stream = await self.llm.astream_chat(
-            messages=chat_history,
-        )
-        ctx.write_event_to_stream(
-            UIEvent(
-                type="ui_event",
-                data=UIEventData(
-                    state="completed",
-                    requirement=event.requirement.requirement,
-                ),
-            )
-        )
-        return StopEvent(result=response_stream)

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

@@ -1,59 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) multi-agents project using [Workflows](https://docs.llamaindex.ai/en/stable/understanding/workflows/).
-
-## Getting Started
-
-First, setup the environment with uv:
-
-> **_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.
-Make sure you have set the `OPENAI_API_KEY` for the LLM and the `E2B_API_KEY` for the code interpreter. You can get the E2B API key from [here](https://e2b.dev).
-
-Second, generate the embeddings of the documents in the `./data` directory:
-
-```shell
-uv run generate
-```
-
-Third, run the development server:
-
-```shell
-uv run fastapi dev
-```
-
-Then open [http://localhost:8000](http://localhost:8000) with your browser to start the chat UI.
-
-To start the app optimized for **production**, run:
-
-```
-uv run fastapi run
-```
-
-## Configure LLM and Embedding Model
-
-You can configure [LLM model](https://docs.llamaindex.ai/en/stable/module_guides/models/llms) and [embedding model](https://docs.llamaindex.ai/en/stable/module_guides/models/embeddings) in [settings.py](app/settings.py).
-
-## Use Case
-
-We have prepared an [example workflow](./app/workflow.py) for the financial report use case, where you can ask questions about the example documents in the [./data](./data) directory.
-
-You can start by sending an request on the [chat UI](http://localhost:8000) or you can test the `/api/chat` endpoint with the following curl request:
-
-```
-curl --location 'localhost:8000/api/chat' \
---header 'Content-Type: application/json' \
---data '{ "messages": [{ "role": "user", "content": "Create a report comparing the finances of Apple and Tesla" }] }'
-```
-
-## 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/use-cases/python/financial_report/workflow.py

@@ -1,333 +0,0 @@
-import os
-from typing import List, Optional
-
-from app.index import get_index
-from llama_index.core import Settings
-from llama_index.core.base.llms.types import ChatMessage, MessageRole
-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
-from llama_index.core.workflow import (
-    Context,
-    Event,
-    StartEvent,
-    StopEvent,
-    Workflow,
-    step,
-)
-from llama_index.server.api.models import AgentRunEvent, ChatRequest
-from llama_index.server.settings import server_settings
-from llama_index.server.tools.document_generator import DocumentGenerator
-from llama_index.server.tools.index import get_query_engine_tool
-from llama_index.server.tools.interpreter import E2BCodeInterpreter
-from llama_index.server.utils.agent_tool import (
-    call_tools,
-    chat_with_tools,
-)
-
-
-def create_workflow(chat_request: Optional[ChatRequest] = None) -> Workflow:
-    index = get_index(chat_request=chat_request)
-    if index is None:
-        raise ValueError(
-            "Index is not found. Try run generation script to create the index first."
-        )
-    query_engine_tool = get_query_engine_tool(index=index)
-    e2b_api_key = os.getenv("E2B_API_KEY")
-    if e2b_api_key is None:
-        raise ValueError(
-            "E2B_API_KEY is required to use the code interpreter tool. Please check README.md to know how to get the key."
-        )
-    code_interpreter_tool = E2BCodeInterpreter(api_key=e2b_api_key).to_tool()
-    document_generator_tool = DocumentGenerator(
-        file_server_url_prefix=server_settings.file_server_url_prefix,
-    ).to_tool()
-
-    return FinancialReportWorkflow(
-        query_engine_tool=query_engine_tool,
-        code_interpreter_tool=code_interpreter_tool,
-        document_generator_tool=document_generator_tool,
-        timeout=180,
-    )
-
-
-class InputEvent(Event):
-    input: List[ChatMessage]
-    response: bool = False
-
-
-class ResearchEvent(Event):
-    input: list[ToolSelection]
-
-
-class AnalyzeEvent(Event):
-    input: list[ToolSelection] | ChatMessage
-
-
-class ReportEvent(Event):
-    input: list[ToolSelection]
-
-
-class FinancialReportWorkflow(Workflow):
-    """
-    A workflow to generate a financial report using indexed documents.
-
-    Requirements:
-    - Indexed documents containing financial data and a query engine tool to search them
-    - A code interpreter tool to analyze data and generate reports
-    - A document generator tool to create report files
-
-    Steps:
-    1. LLM Input: The LLM determines the next step based on function calling.
-       For example, if the model requests the query engine tool, it returns a ResearchEvent;
-       if it requests document generation, it returns a ReportEvent.
-    2. Research: Uses the query engine to find relevant chunks from indexed documents.
-       After gathering information, it requests analysis (step 3).
-    3. Analyze: Uses a custom prompt to analyze research results and can call the code
-       interpreter tool for visualization or calculation. Returns results to the LLM.
-    4. Report: Uses the document generator tool to create a report. Returns results to the LLM.
-    """
-
-    _default_system_prompt = """
-    You are a financial analyst who are given a set of tools to help you.
-    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,
-        query_engine_tool: QueryEngineTool,
-        code_interpreter_tool: FunctionTool,
-        document_generator_tool: FunctionTool,
-        llm: Optional[FunctionCallingLLM] = None,
-        system_prompt: Optional[str] = None,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-        self.system_prompt = system_prompt or self._default_system_prompt
-        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 code_interpreter_tool is not None, "Code interpreter 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,
-            self.document_generator_tool,
-        ]
-        self.llm: FunctionCallingLLM = llm or Settings.llm  # type: ignore
-        assert isinstance(self.llm, FunctionCallingLLM)
-        self.memory = ChatMemoryBuffer.from_defaults(llm=self.llm)
-
-    @step()
-    async def prepare_chat_history(self, ctx: Context, ev: StartEvent) -> InputEvent:
-        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(
-                role=MessageRole.SYSTEM, content=self.system_prompt
-            )
-            self.memory.put(system_msg)
-
-        return InputEvent(input=self.memory.get())
-
-    @step()
-    async def handle_llm_input(  # type: ignore
-        self,
-        ctx: Context,
-        ev: InputEvent,
-    ) -> ResearchEvent | AnalyzeEvent | ReportEvent | StopEvent:
-        """
-        Handle an LLM input and decide the next step.
-        """
-        # Always use the latest chat history from the input
-        chat_history: list[ChatMessage] = ev.input
-        # Get tool calls
-        response = await chat_with_tools(
-            self.llm,
-            self.tools,  # type: ignore
-            chat_history,
-        )
-        if not response.has_tool_calls():
-            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():
-            self.memory.put(
-                ChatMessage(
-                    role=MessageRole.ASSISTANT,
-                    content="Cannot call different tools at the same time. Try calling one tool at a time.",
-                )
-            )
-            return InputEvent(input=self.memory.get())  # type: ignore
-        self.memory.put(response.tool_call_message)
-        match response.tool_name():
-            case self.code_interpreter_tool.metadata.name:
-                return AnalyzeEvent(input=response.tool_calls)
-            case self.document_generator_tool.metadata.name:
-                return ReportEvent(input=response.tool_calls)
-            case self.query_engine_tool.metadata.name:
-                return ResearchEvent(input=response.tool_calls)
-            case _:
-                raise ValueError(f"Unknown tool: {response.tool_name()}")
-
-    @step()
-    async def research(self, ctx: Context, ev: ResearchEvent) -> AnalyzeEvent:
-        """
-        Do a research to gather information for the user's request.
-        A researcher should have these tools: query engine, search engine, etc.
-        """
-        ctx.write_event_to_stream(
-            AgentRunEvent(
-                name="Researcher",
-                msg="Starting research",
-            )
-        )
-        tool_calls = ev.input
-
-        tool_call_outputs = await call_tools(
-            ctx=ctx,
-            agent_name="Researcher",
-            tools=[self.query_engine_tool],
-            tool_calls=tool_calls,
-        )
-        for tool_call_output in tool_call_outputs:
-            self.memory.put(
-                ChatMessage(
-                    role=MessageRole.TOOL,
-                    content=tool_call_output.tool_output.content,
-                    additional_kwargs={
-                        "name": tool_call_output.tool_output.tool_name,
-                        "tool_call_id": tool_call_output.tool_call_id,
-                    },
-                )
-            )
-        return AnalyzeEvent(
-            input=ChatMessage(
-                role=MessageRole.ASSISTANT,
-                content="Researcher: I've finished the research. Please analyze the result.",
-            ),
-        )
-
-    @step()
-    async def analyze(self, ctx: Context, ev: AnalyzeEvent) -> InputEvent:
-        """
-        Analyze the research result.
-        """
-        ctx.write_event_to_stream(
-            AgentRunEvent(
-                name="Analyst",
-                msg="Starting analysis",
-            )
-        )
-        event_requested_by_workflow_llm = isinstance(ev.input, list)
-        # Requested by the workflow LLM Input step, it's a tool call
-        if event_requested_by_workflow_llm:
-            # Set the tool calls
-            tool_calls = ev.input
-        else:
-            # Otherwise, it's triggered by the research step
-            # Use a custom prompt and independent memory for the analyst agent
-            analysis_prompt = """
-            You are a financial analyst, you are given a research result and a set of tools to help you.
-            Always use the given information, don't make up anything yourself. If there is not enough information, you can asking for more information.
-            If you have enough numerical information, it's good to include some charts/visualizations to the report so you can use the code interpreter tool to generate a report.
-            """
-            # This is handled by analyst agent
-            # Clone the shared memory to avoid conflicting with the workflow.
-            chat_history = self.memory.get()
-            chat_history.append(
-                ChatMessage(role=MessageRole.SYSTEM, content=analysis_prompt)
-            )
-            chat_history.append(ev.input)  # type: ignore
-            # Check if the analyst agent needs to call tools
-            response = await chat_with_tools(
-                self.llm,
-                [self.code_interpreter_tool],
-                chat_history,
-            )
-            if not response.has_tool_calls():
-                # If no tool call, fallback analyst message to the workflow
-                msg_content = await response.full_response()
-                analyst_msg = ChatMessage(
-                    role=MessageRole.ASSISTANT,
-                    content=f"Analyst: "
-                    f"\nHere is the analysis result: {msg_content}"
-                    "\nUse it for other steps or response the content to the user.",
-                )
-                self.memory.put(analyst_msg)
-                return InputEvent(input=self.memory.get())
-            else:
-                tool_calls = response.tool_calls
-                self.memory.put(response.tool_call_message)
-
-        # Call tools
-        tool_call_outputs = await call_tools(
-            ctx=ctx,
-            agent_name="Analyst",
-            tools=[self.code_interpreter_tool],
-            tool_calls=tool_calls,  # type: ignore
-        )
-        for tool_call_output in tool_call_outputs:
-            self.memory.put(
-                ChatMessage(
-                    role=MessageRole.TOOL,
-                    content=tool_call_output.tool_output.content,
-                    additional_kwargs={
-                        "name": tool_call_output.tool_output.tool_name,
-                        "tool_call_id": tool_call_output.tool_call_id,
-                    },
-                )
-            )
-
-        # Fallback to the input with the latest chat history
-        return InputEvent(input=self.memory.get())
-
-    @step()
-    async def report(self, ctx: Context, ev: ReportEvent) -> InputEvent:
-        """
-        Generate a report based on the analysis result.
-        """
-        ctx.write_event_to_stream(
-            AgentRunEvent(
-                name="Reporter",
-                msg="Starting report generation",
-            )
-        )
-        tool_calls = ev.input
-        tool_call_outputs = await call_tools(
-            ctx=ctx,
-            agent_name="Reporter",
-            tools=[self.document_generator_tool],
-            tool_calls=tool_calls,
-        )
-        for tool_call_output in tool_call_outputs:
-            self.memory.put(
-                ChatMessage(
-                    role=MessageRole.TOOL,
-                    content=tool_call_output.tool_output.content,
-                    additional_kwargs={
-                        "name": tool_call_output.tool_output.tool_name,
-                        "tool_call_id": tool_call_output.tool_call_id,
-                    },
-                )
-            )
-        # After the tool calls, fallback to the input with the latest chat history
-        return InputEvent(input=self.memory.get())

packages/create-llama/templates/components/use-cases/typescript/agentic_rag/README-template.md

@@ -1,52 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) project bootstrapped with [`create-llama`](https://github.com/run-llama/LlamaIndexTS/tree/main/packages/create-llama).
-
-## Getting Started
-
-First, install the dependencies:
-
-```
-npm install
-```
-
-Then check the parameters that have been pre-configured in the `.env` file in this directory.
-Make sure you have set the `OPENAI_API_KEY` for the LLM.
-
-Second, generate the embeddings of the example documents in the `./data` directory:
-
-```
-npm run generate
-```
-
-Third, run the development server:
-
-```
-npm run dev
-```
-
-Open [http://localhost:3000](http://localhost:3000) with your browser to see the chat UI.
-
-## Configure LLM and Embedding Model
-
-You can configure [LLM model](https://ts.llamaindex.ai/docs/llamaindex/modules/llms) and [embedding model](https://ts.llamaindex.ai/docs/llamaindex/modules/embeddings) in the [settings file](src/app/settings.ts).
-
-## Use Case
-
-We have prepared an [example workflow](./src/app/workflow.ts) for the agentic RAG use case, where you can ask questions about the example documents in the [./data](./data) directory.
-
-You can start by sending an request on the [chat UI](http://localhost:3000) or you can test the `/api/chat` endpoint with the following curl request:
-
-```shell
-curl --location 'localhost:3000/api/chat' \
---header 'Content-Type: application/json' \
---data '{ "messages": [{ "role": "user", "content": "What standards for a letter exist?" }] }'
-```
-
-## Learn More
-
-To learn more about LlamaIndex, take a look at the following resources:
-
-- [LlamaIndex Documentation](https://docs.llamaindex.ai) - learn about LlamaIndex (Python features).
-- [LlamaIndexTS Documentation](https://ts.llamaindex.ai/docs/llamaindex) - learn about LlamaIndex (Typescript features).
-- [Agent Workflows Introduction](https://ts.llamaindex.ai/docs/llamaindex/modules/agent_workflow) - learn about LlamaIndexTS Agent Workflows.
-
-You can check out [the LlamaIndexTS GitHub repository](https://github.com/run-llama/LlamaIndexTS) - your feedback and contributions are welcome!

packages/create-llama/templates/components/use-cases/typescript/agentic_rag/src/app/workflow.ts

@@ -1,16 +0,0 @@
-import { agent } from "@llamaindex/workflow";
-import { getIndex } from "./data";
-
-export const workflowFactory = async (reqBody: any) => {
-  const index = await getIndex(reqBody?.data);
-
-  const queryEngineTool = index.queryTool({
-    metadata: {
-      name: "query_document",
-      description: `This tool can retrieve information about Apple and Tesla financial data`,
-    },
-    includeSourceNodes: true,
-  });
-
-  return agent({ tools: [queryEngineTool] });
-};

packages/create-llama/templates/components/use-cases/typescript/agentic_rag/src/generate.ts

@@ -1,39 +0,0 @@
-import { SimpleDirectoryReader } from "@llamaindex/readers/directory";
-import "dotenv/config";
-import { storageContextFromDefaults, VectorStoreIndex } from "llamaindex";
-import { initSettings } from "./app/settings";
-
-async function generateDatasource() {
-  console.log(`Generating storage context...`);
-  // Split documents, create embeddings and store them in the storage context
-  const storageContext = await storageContextFromDefaults({
-    persistDir: "storage",
-  });
-  // load documents from current directory into an index
-  const reader = new SimpleDirectoryReader();
-  const documents = await reader.loadData("data");
-
-  await VectorStoreIndex.fromDocuments(documents, {
-    storageContext,
-  });
-  console.log("Storage context successfully generated.");
-}
-
-(async () => {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  initSettings();
-
-  if (command === "ui") {
-    console.error("This project doesn't use any custom UI.");
-    return;
-  } else {
-    if (command !== "datasource") {
-      console.error(
-        `Unrecognized command: ${command}. Generating datasource by default.`,
-      );
-    }
-    await generateDatasource();
-  }
-})();

packages/create-llama/templates/components/use-cases/typescript/code_generator/README-template.md

@@ -1,53 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) project bootstrapped with [`create-llama`](https://github.com/run-llama/LlamaIndexTS/tree/main/packages/create-llama).
-
-## Getting Started
-
-First, install the dependencies:
-
-```
-npm install
-```
-
-Third, run the development server:
-
-```
-npm run dev
-```
-
-Open [http://localhost:3000](http://localhost:3000) with your browser to see the chat UI.
-
-## Configure LLM and Embedding Model
-
-You can configure [LLM model](https://ts.llamaindex.ai/docs/llamaindex/modules/llms) in the [settings file](src/app/settings.ts).
-
-## Custom UI Components
-
-We have a custom component located in `components/ui_event.jsx`. This is used to display the state of artifact workflows in UI. You can regenerate a new UI component from the workflow event schema by running the following command:
-
-```
-npm run generate:ui
-```
-
-## Use Case
-
-AI-powered code generator that can help you generate app with a chat interface, code editor and app preview.
-
-To update the workflow, you can modify the code in [`workflow.ts`](app/workflow.ts).
-
-You can start by sending an request on the [chat UI](http://localhost:3000) or you can test the `/api/chat` endpoint with the following curl request:
-
-```shell
-curl --location 'localhost:3000/api/chat' \
---header 'Content-Type: application/json' \
---data '{ "messages": [{ "role": "user", "content": "Compare the financial performance of Apple and Tesla" }] }'
-```
-
-## Learn More
-
-To learn more about LlamaIndex, take a look at the following resources:
-
-- [LlamaIndex Documentation](https://docs.llamaindex.ai) - learn about LlamaIndex (Python features).
-- [LlamaIndexTS Documentation](https://ts.llamaindex.ai/docs/llamaindex) - learn about LlamaIndex (Typescript features).
-- [Workflows Introduction](https://ts.llamaindex.ai/docs/llamaindex/modules/workflows) - learn about LlamaIndexTS workflows.
-
-You can check out [the LlamaIndexTS GitHub repository](https://github.com/run-llama/LlamaIndexTS) - your feedback and contributions are welcome!

packages/create-llama/templates/components/use-cases/typescript/code_generator/src/app/workflow.ts

@@ -1,350 +0,0 @@
-import { extractLastArtifact } from "@llamaindex/server";
-import { ChatMemoryBuffer, MessageContent, Settings } from "llamaindex";
-
-import {
-  agentStreamEvent,
-  createStatefulMiddleware,
-  createWorkflow,
-  startAgentEvent,
-  stopAgentEvent,
-  workflowEvent,
-} from "@llamaindex/workflow";
-
-import { z } from "zod";
-
-export const RequirementSchema = z.object({
-  next_step: z.enum(["answering", "coding"]),
-  language: z.string().nullable().optional(),
-  file_name: z.string().nullable().optional(),
-  requirement: z.string(),
-});
-
-export type Requirement = z.infer<typeof RequirementSchema>;
-
-export const UIEventSchema = z.object({
-  type: z.literal("ui_event"),
-  data: z.object({
-    state: z
-      .enum(["plan", "generate", "completed"])
-      .describe(
-        "The current state of the workflow: 'plan', 'generate', or 'completed'.",
-      ),
-    requirement: z
-      .string()
-      .optional()
-      .describe(
-        "An optional requirement creating or updating a code, if applicable.",
-      ),
-  }),
-});
-
-export type UIEvent = z.infer<typeof UIEventSchema>;
-const planEvent = workflowEvent<{
-  userInput: MessageContent;
-  context?: string | undefined;
-}>();
-
-const generateArtifactEvent = workflowEvent<{
-  requirement: Requirement;
-}>();
-
-const synthesizeAnswerEvent = workflowEvent<object>();
-
-const uiEvent = workflowEvent<UIEvent>();
-
-const artifactEvent = workflowEvent<{
-  type: "artifact";
-  data: {
-    type: "code";
-    created_at: number;
-    data: {
-      language: string;
-      file_name: string;
-      code: string;
-    };
-  };
-}>();
-
-export function workflowFactory(reqBody: any) {
-  const llm = Settings.llm;
-
-  const { withState, getContext } = createStatefulMiddleware(() => {
-    return {
-      memory: new ChatMemoryBuffer({ llm }),
-      lastArtifact: extractLastArtifact(reqBody),
-    };
-  });
-  const workflow = withState(createWorkflow());
-
-  workflow.handle([startAgentEvent], async ({ data }) => {
-    const { userInput, chatHistory = [] } = data;
-    // Prepare chat history
-    const { state } = getContext();
-    // Put user input to the memory
-    if (!userInput) {
-      throw new Error("Missing user input to start the workflow");
-    }
-    state.memory.set(chatHistory);
-    state.memory.put({ role: "user", content: userInput });
-
-    return planEvent.with({
-      userInput: userInput,
-      context: state.lastArtifact
-        ? JSON.stringify(state.lastArtifact)
-        : undefined,
-    });
-  });
-
-  workflow.handle([planEvent], async ({ data: planData }) => {
-    const { sendEvent } = getContext();
-    const { state } = getContext();
-    sendEvent(
-      uiEvent.with({
-        type: "ui_event",
-        data: {
-          state: "plan",
-        },
-      }),
-    );
-    const user_msg = planData.userInput;
-    const context = planData.context
-      ? `## The context is: \n${planData.context}\n`
-      : "";
-    const prompt = `
-You are a product analyst responsible for analyzing the user's request and providing the next step for code or document generation.
-You are helping user with their code artifact. To update the code, you need to plan a coding step.
-
-Follow these instructions:
-1. Carefully analyze the conversation history and the user's request to determine what has been done and what the next step should be.
-2. The next step must be one of the following two options:
-    - "coding": To make the changes to the current code.
-    - "answering": If you don't need to update the current code or need clarification from the user.
-Important: Avoid telling the user to update the code themselves, you are the one who will update the code (by planning a coding step).
-3. If the next step is "coding", you may specify the language ("typescript" or "python") and file_name if known, otherwise set them to null. 
-4. The requirement must be provided clearly what is the user request and what need to be done for the next step in details
-    as precise and specific as possible, don't be stingy with in the requirement.
-5. If the next step is "answering", set language and file_name to null, and the requirement should describe what to answer or explain to the user.
-6. Be concise; only return the requirements for the next step.
-7. The requirements must be in the following format:
-    \`\`\`json
-    {
-        "next_step": "answering" | "coding",
-        "language": "typescript" | "python" | null,
-        "file_name": string | null,
-        "requirement": string
-    }
-    \`\`\`
-
-## Example 1:
-User request: Create a calculator app.
-You should return:
-\`\`\`json
-{
-    "next_step": "coding",
-    "language": "typescript",
-    "file_name": "calculator.tsx",
-    "requirement": "Generate code for a calculator app that has a simple UI with a display and button layout. The display should show the current input and the result. The buttons should include basic operators, numbers, clear, and equals. The calculation should work correctly."
-}
-\`\`\`
-
-## Example 2:
-User request: Explain how the game loop works.
-Context: You have already generated the code for a snake game.
-You should return:
-\`\`\`json
-{
-    "next_step": "answering",
-    "language": null,
-    "file_name": null,
-    "requirement": "The user is asking about the game loop. Explain how the game loop works."
-}
-\`\`\`
-
-${context}
-
-Now, plan the user's next step for this request:
-${user_msg}
-`;
-
-    const response = await llm.complete({
-      prompt,
-    });
-    // parse the response to Requirement
-    // 1. use regex to find the json block
-    const jsonBlock = response.text.match(/```json\s*([\s\S]*?)\s*```/);
-    if (!jsonBlock) {
-      throw new Error("No JSON block found in the response.");
-    }
-    const requirement = RequirementSchema.parse(JSON.parse(jsonBlock[1]));
-    state.memory.put({
-      role: "assistant",
-      content: `The plan for next step: \n${response.text}`,
-    });
-
-    if (requirement.next_step === "coding") {
-      return generateArtifactEvent.with({
-        requirement,
-      });
-    } else {
-      return synthesizeAnswerEvent.with({});
-    }
-  });
-
-  workflow.handle([generateArtifactEvent], async ({ data: planData }) => {
-    const { sendEvent } = getContext();
-    const { state } = getContext();
-
-    sendEvent(
-      uiEvent.with({
-        type: "ui_event",
-        data: {
-          state: "generate",
-          requirement: planData.requirement.requirement,
-        },
-      }),
-    );
-
-    const previousArtifact = state.lastArtifact
-      ? JSON.stringify(state.lastArtifact)
-      : "There is no previous artifact";
-    const requirementText = planData.requirement.requirement;
-
-    const prompt = `
-        You are a skilled developer who can help user with coding.
-        You are given a task to generate or update a code for a given requirement.
-
-        ## Follow these instructions:
-        **1. Carefully read the user's requirements.** 
-           If any details are ambiguous or missing, make reasonable assumptions and clearly reflect those in your output.
-           If the previous code is provided:
-           + Carefully analyze the code with the request to make the right changes.
-           + Avoid making a lot of changes from the previous code if the request is not to write the code from scratch again.
-        **2. For code requests:**
-           - If the user does not specify a framework or language, default to a React component using the Next.js framework.
-           - For Next.js, use Shadcn UI components, Typescript, @types/node, @types/react, @types/react-dom, PostCSS, and TailwindCSS.
-           The import pattern should be:
-           \`\`\`typescript
-           import { ComponentName } from "@/components/ui/component-name"
-           import { Markdown } from "@llamaindex/chat-ui"
-           import { cn } from "@/lib/utils"
-           \`\`\`
-           - Ensure the code is idiomatic, production-ready, and includes necessary imports.
-           - Only generate code relevant to the user's request—do not add extra boilerplate.
-        **3. Don't be verbose on response**
-           - No other text or comments only return the code which wrapped by \`\`\`language\`\`\` block.
-           - If the user's request is to update the code, only return the updated code.
-        **4. Only the following languages are allowed: "typescript", "python".**
-        **5. If there is no code to update, return the reason without any code block.**
-           
-        ## Example:
-        \`\`\`typescript
-        import React from "react";
-        import { Button } from "@/components/ui/button";
-        import { cn } from "@/lib/utils";
-
-        export default function MyComponent() {
-        return (
-           <div className="flex flex-col items-center justify-center h-screen">
-              <Button>Click me</Button>
-           </div>
-        );
-        }
-        \`\`\`
-
-        The previous code is:
-        {previousArtifact}
-
-        Now, i have to generate the code for the following requirement:
-        {requirement}
-      `
-      .replace("{previousArtifact}", previousArtifact)
-      .replace("{requirement}", requirementText);
-
-    const response = await llm.complete({
-      prompt,
-    });
-
-    // Extract the code from the response
-    const codeMatch = response.text.match(/```(\w+)([\s\S]*)```/);
-    if (!codeMatch) {
-      return synthesizeAnswerEvent.with({});
-    }
-
-    const code = codeMatch[2].trim();
-
-    // Put the generated code to the memory
-    state.memory.put({
-      role: "assistant",
-      content: `Updated the code: \n${response.text}`,
-    });
-
-    // To show the Canvas panel for the artifact
-    sendEvent(
-      artifactEvent.with({
-        type: "artifact",
-        data: {
-          type: "code",
-          created_at: Date.now(),
-          data: {
-            language: planData.requirement.language || "",
-            file_name: planData.requirement.file_name || "",
-            code,
-          },
-        },
-      }),
-    );
-
-    return synthesizeAnswerEvent.with({});
-  });
-
-  workflow.handle([synthesizeAnswerEvent], async () => {
-    const { sendEvent } = getContext();
-    const { state } = getContext();
-
-    const chatHistory = await state.memory.getMessages();
-    const messages = [
-      ...chatHistory,
-      {
-        role: "system" as const,
-        content: `
-        You are a helpful assistant who is responsible for explaining the work to the user.
-        Based on the conversation history, provide an answer to the user's question. 
-        The user has access to the code so avoid mentioning the whole code again in your response.
-      `,
-      },
-    ];
-
-    const responseStream = await llm.chat({
-      messages,
-      stream: true,
-    });
-
-    sendEvent(
-      uiEvent.with({
-        type: "ui_event",
-        data: {
-          state: "completed",
-        },
-      }),
-    );
-
-    let response = "";
-    for await (const chunk of responseStream) {
-      response += chunk.delta;
-      sendEvent(
-        agentStreamEvent.with({
-          delta: chunk.delta,
-          response: "",
-          currentAgentName: "assistant",
-          raw: chunk,
-        }),
-      );
-    }
-
-    return stopAgentEvent.with({
-      result: response,
-    });
-  });
-
-  return workflow;
-}

packages/create-llama/templates/components/use-cases/typescript/deep_research/README-template.md

@@ -1,64 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) project bootstrapped with [`create-llama`](https://github.com/run-llama/LlamaIndexTS/tree/main/packages/create-llama).
-
-## Getting Started
-
-First, install the dependencies:
-
-```
-npm install
-```
-
-Then check the parameters that have been pre-configured in the `.env` file in this directory.
-Make sure you have set the `OPENAI_API_KEY` for the LLM.
-
-Second, generate the embeddings of the example documents in the `./data` directory:
-
-```
-npm run generate
-```
-
-Third, run the development server:
-
-```
-npm run dev
-```
-
-Open [http://localhost:3000](http://localhost:3000) with your browser to see the chat UI.
-
-## Configure LLM and Embedding Model
-
-You can configure [LLM model](https://ts.llamaindex.ai/docs/llamaindex/modules/llms) and [embedding model](https://ts.llamaindex.ai/docs/llamaindex/modules/embeddings) in the [settings file](src/app/settings.ts).
-
-## Custom UI Components
-
-For Deep Research, we have a custom component located in `components/ui_event.jsx`. This is used to display the results of the deep research workflow in a more user-friendly way
-
-### Generate a new UI Component from workflow event
-
-You can regenerate a new UI component from the workflow event schema by running the following command:
-
-```
-npm run generate:ui
-```
-
-## Use Case
-
-We have prepared an [example workflow](./src/app/workflow.ts) for the Deep Research use case, where you can request a detailed answer about the example documents in the [./data](./data) directory.
-
-You can start by sending an request on the [chat UI](http://localhost:3000) or you can test the `/api/chat` endpoint with the following curl request:
-
-```shell
-curl --location 'localhost:3000/api/chat' \
---header 'Content-Type: application/json' \
---data '{ "messages": [{ "role": "user", "content": "Compare the financial performance of Apple and Tesla" }] }'
-```
-
-## Learn More
-
-To learn more about LlamaIndex, take a look at the following resources:
-
-- [LlamaIndex Documentation](https://docs.llamaindex.ai) - learn about LlamaIndex (Python features).
-- [LlamaIndexTS Documentation](https://ts.llamaindex.ai/docs/llamaindex) - learn about LlamaIndex (Typescript features).
-- [Workflows Introduction](https://ts.llamaindex.ai/docs/llamaindex/modules/workflows) - learn about LlamaIndexTS workflows.
-
-You can check out [the LlamaIndexTS GitHub repository](https://github.com/run-llama/LlamaIndexTS) - your feedback and contributions are welcome!

packages/create-llama/templates/components/use-cases/typescript/deep_research/src/app/workflow.ts

@@ -1,416 +0,0 @@
-import { toSourceEvent } from "@llamaindex/server";
-import {
-  agentStreamEvent,
-  createStatefulMiddleware,
-  createWorkflow,
-  startAgentEvent,
-  stopAgentEvent,
-  workflowEvent,
-} from "@llamaindex/workflow";
-import {
-  ChatMemoryBuffer,
-  LlamaCloudIndex,
-  MessageContent,
-  Metadata,
-  MetadataMode,
-  NodeWithScore,
-  PromptTemplate,
-  Settings,
-  VectorStoreIndex,
-  extractText,
-} from "llamaindex";
-import { randomUUID } from "node:crypto";
-import { z } from "zod";
-import { getIndex } from "./data";
-
-// workflow factory
-export const workflowFactory = async (reqBody: any) => {
-  const index = await getIndex(reqBody?.data);
-  return getWorkflow(index);
-};
-
-// workflow configs
-const MAX_QUESTIONS = 6; // max number of questions to research, research will stop when this number is reached
-const TOP_K = 10; // number of nodes to retrieve from the vector store
-
-const createPlanResearchPrompt = new PromptTemplate({
-  template: `
-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>
-`,
-  templateVars: [
-    "context_str",
-    "conversation_context",
-    "enhanced_prompt",
-    "user_request",
-  ],
-});
-
-const researchPrompt = new PromptTemplate({
-  template: `
-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}
-`,
-  templateVars: ["context_str", "question"],
-});
-
-const WRITE_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.
-`;
-
-// workflow events
-type ResearchQuestion = { questionId: string; question: string };
-type ResearchResult = ResearchQuestion & { answer: string };
-
-// class PlanResearchEvent extends WorkflowEvent<{}> {}
-const planResearchEvent = workflowEvent<{}>();
-const researchEvent = workflowEvent<ResearchQuestion>();
-const reportEvent = workflowEvent<{}>();
-
-export const UIEventSchema = z
-  .object({
-    event: z
-      .enum(["retrieve", "analyze", "answer"])
-      .describe(
-        "The type of event. DeepResearch has 3 main stages:\n1. retrieve: Retrieve the context from the vector store\n2. analyze: Analyze the context and generate a research questions to answer\n3. answer: Answer the provided questions. Each question has a unique id, when the state is done, the event will have the answer for the question.",
-      ),
-    state: z
-      .enum(["pending", "inprogress", "done", "error"])
-      .describe("The state for each event"),
-    id: z.string().optional().describe("The id of the question"),
-    question: z
-      .string()
-      .optional()
-      .describe("The question generated by the LLM"),
-    answer: z.string().optional().describe("The answer generated by the LLM"),
-  })
-  .describe("DeepResearchEvent");
-
-type UIEventData = z.infer<typeof UIEventSchema>;
-
-const uiEvent = workflowEvent<{
-  type: "ui_event";
-  data: UIEventData;
-}>();
-
-// workflow definition
-export function getWorkflow(index: VectorStoreIndex | LlamaCloudIndex) {
-  const retriever = index.asRetriever({ similarityTopK: TOP_K });
-  const { withState, getContext } = createStatefulMiddleware(() => {
-    return {
-      memory: new ChatMemoryBuffer({
-        llm: Settings.llm,
-        chatHistory: [],
-      }),
-      contextNodes: [] as NodeWithScore<Metadata>[],
-      userRequest: "" as MessageContent,
-      totalQuestions: 0,
-      researchResults: [] as ResearchResult[],
-    };
-  });
-  const workflow = withState(createWorkflow());
-
-  workflow.handle([startAgentEvent], async ({ data }) => {
-    const { userInput, chatHistory = [] } = data;
-    const { sendEvent, state } = getContext();
-    if (!userInput) throw new Error("Invalid input");
-
-    state.memory.set(chatHistory);
-    state.memory.put({ role: "user", content: userInput });
-    state.userRequest = userInput;
-    sendEvent(
-      uiEvent.with({
-        type: "ui_event",
-        data: {
-          event: "retrieve",
-          state: "inprogress",
-        },
-      }),
-    );
-
-    const retrievedNodes = await retriever.retrieve({ query: userInput });
-
-    sendEvent(toSourceEvent(retrievedNodes));
-    sendEvent(
-      uiEvent.with({
-        type: "ui_event",
-        data: { event: "retrieve", state: "done" },
-      }),
-    );
-
-    state.contextNodes.push(...retrievedNodes);
-
-    return planResearchEvent.with({});
-  });
-
-  workflow.handle([planResearchEvent], async ({ data }) => {
-    const { sendEvent, state, stream } = getContext();
-
-    sendEvent(
-      uiEvent.with({
-        type: "ui_event",
-        data: { event: "analyze", state: "inprogress" },
-      }),
-    );
-
-    const { decision, researchQuestions, cancelReason } =
-      await createResearchPlan(
-        state.memory,
-        state.contextNodes
-          .map((node) => node.node.getContent(MetadataMode.NONE))
-          .join("\n"),
-        enhancedPrompt(state.totalQuestions),
-        state.userRequest,
-      );
-
-    sendEvent(
-      uiEvent.with({
-        type: "ui_event",
-        data: { event: "analyze", state: "done" },
-      }),
-    );
-    if (decision === "cancel") {
-      sendEvent(
-        uiEvent.with({
-          type: "ui_event",
-          data: { event: "analyze", state: "done" },
-        }),
-      );
-      return agentStreamEvent.with({
-        delta: cancelReason ?? "Research cancelled without any reason.",
-        response: cancelReason ?? "Research cancelled without any reason.",
-        currentAgentName: "",
-        raw: null,
-      });
-    }
-    if (decision === "research" && researchQuestions.length > 0) {
-      state.totalQuestions += researchQuestions.length;
-      state.memory.put({
-        role: "assistant",
-        content:
-          "We need to find answers to the following questions:\n" +
-          researchQuestions.join("\n"),
-      });
-      researchQuestions.forEach(({ questionId: id, question }) => {
-        sendEvent(
-          uiEvent.with({
-            type: "ui_event",
-            data: { event: "answer", state: "pending", id, question },
-          }),
-        );
-        sendEvent(researchEvent.with({ questionId: id, question }));
-      });
-      const events = await stream
-        .until(() => state.researchResults.length === researchQuestions.length)
-        .toArray();
-      return planResearchEvent.with({});
-    }
-    state.memory.put({
-      role: "assistant",
-      content: "No more idea to analyze. We should report the answers.",
-    });
-    sendEvent(
-      uiEvent.with({
-        type: "ui_event",
-        data: { event: "analyze", state: "done" },
-      }),
-    );
-    return reportEvent.with({});
-  });
-
-  workflow.handle([researchEvent], async ({ data }) => {
-    const { sendEvent, state } = getContext();
-    const { questionId, question } = data;
-
-    sendEvent(
-      uiEvent.with({
-        type: "ui_event",
-        data: {
-          event: "answer",
-          state: "inprogress",
-          id: questionId,
-          question,
-        },
-      }),
-    );
-
-    const answer = await answerQuestion(
-      contextStr(state.contextNodes),
-      question,
-    );
-    state.researchResults.push({ questionId, question, answer });
-
-    state.memory.put({
-      role: "assistant",
-      content: `<Question>${question}</Question>\n<Answer>${answer}</Answer>`,
-    });
-
-    sendEvent(
-      uiEvent.with({
-        type: "ui_event",
-        data: {
-          event: "answer",
-          state: "done",
-          id: questionId,
-          question,
-          answer,
-        },
-      }),
-    );
-  });
-
-  workflow.handle([reportEvent], async ({ data }) => {
-    const { sendEvent, state } = getContext();
-    const chatHistory = await state.memory.getAllMessages();
-    const messages = chatHistory.concat([
-      {
-        role: "system",
-        content: WRITE_REPORT_PROMPT,
-      },
-      {
-        role: "user",
-        content:
-          "Write a report addressing the user request based on the research provided the context",
-      },
-    ]);
-
-    const stream = await Settings.llm.chat({ messages, stream: true });
-    let response = "";
-    for await (const chunk of stream) {
-      response += chunk.delta;
-      sendEvent(
-        agentStreamEvent.with({
-          delta: chunk.delta,
-          response,
-          currentAgentName: "",
-          raw: stream,
-        }),
-      );
-    }
-    return stopAgentEvent.with({
-      result: response,
-    });
-  });
-
-  return workflow;
-}
-
-const createResearchPlan = async (
-  memory: ChatMemoryBuffer,
-  contextStr: string,
-  enhancedPrompt: string,
-  userRequest: MessageContent,
-) => {
-  const chatHistory = await memory.getMessages();
-
-  const conversationContext = chatHistory
-    .map((message) => `${message.role}: ${message.content}`)
-    .join("\n");
-
-  const prompt = createPlanResearchPrompt.format({
-    context_str: contextStr,
-    conversation_context: conversationContext,
-    enhanced_prompt: enhancedPrompt,
-    user_request: extractText(userRequest),
-  });
-
-  const responseFormat = z.object({
-    decision: z.enum(["research", "write", "cancel"]),
-    researchQuestions: z.array(z.string()),
-    cancelReason: z.string().optional(),
-  });
-
-  const result = await Settings.llm.complete({ prompt, responseFormat });
-  const plan = JSON.parse(result.text) as z.infer<typeof responseFormat>;
-
-  return {
-    ...plan,
-    researchQuestions: plan.researchQuestions.map((question) => ({
-      questionId: randomUUID(),
-      question,
-    })),
-  };
-};
-
-const contextStr = (contextNodes: NodeWithScore<Metadata>[]) => {
-  return contextNodes
-    .map((node) => {
-      const nodeId = node.node.id_;
-      const nodeContent = node.node.getContent(MetadataMode.NONE);
-      return `<Citation id='${nodeId}'>\n${nodeContent}</Citation id='${nodeId}'>`;
-    })
-    .join("\n");
-};
-
-const enhancedPrompt = (totalQuestions: number) => {
-  if (totalQuestions === 0) {
-    return "The student has no questions to research. Let start by providing some questions for the student to research.";
-  }
-
-  if (totalQuestions >= MAX_QUESTIONS) {
-    return `The student has researched ${totalQuestions} questions. Should proceeding writing report or cancel the research if the answers are not enough to write a report.`;
-  }
-
-  return "";
-};
-
-const answerQuestion = async (contextStr: string, question: string) => {
-  const prompt = researchPrompt.format({
-    context_str: contextStr,
-    question,
-  });
-  const result = await Settings.llm.complete({ prompt });
-  return result.text;
-};

packages/create-llama/templates/components/use-cases/typescript/document_generator/README-template.md

@@ -1,53 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) project bootstrapped with [`create-llama`](https://github.com/run-llama/LlamaIndexTS/tree/main/packages/create-llama).
-
-## Getting Started
-
-First, install the dependencies:
-
-```
-npm install
-```
-
-Third, run the development server:
-
-```
-npm run dev
-```
-
-Open [http://localhost:3000](http://localhost:3000) with your browser to see the chat UI.
-
-## Configure LLM and Embedding Model
-
-You can configure [LLM model](https://ts.llamaindex.ai/docs/llamaindex/modules/llms) in the [settings file](src/app/settings.ts).
-
-## Custom UI Components
-
-We have a custom component located in `components/ui_event.jsx`. This is used to display the state of artifact workflows in UI. You can regenerate a new UI component from the workflow event schema by running the following command:
-
-```
-npm run generate:ui
-```
-
-## Use Case
-
-AI-powered document generator that can help you generate documents with a chat interface and simple markdown editor.
-
-To update the workflow, you can modify the code in [`workflow.ts`](app/workflow.ts).
-
-You can start by sending an request on the [chat UI](http://localhost:3000) or you can test the `/api/chat` endpoint with the following curl request:
-
-```shell
-curl --location 'localhost:3000/api/chat' \
---header 'Content-Type: application/json' \
---data '{ "messages": [{ "role": "user", "content": "Compare the financial performance of Apple and Tesla" }] }'
-```
-
-## Learn More
-
-To learn more about LlamaIndex, take a look at the following resources:
-
-- [LlamaIndex Documentation](https://docs.llamaindex.ai) - learn about LlamaIndex (Python features).
-- [LlamaIndexTS Documentation](https://ts.llamaindex.ai/docs/llamaindex) - learn about LlamaIndex (Typescript features).
-- [Workflows Introduction](https://ts.llamaindex.ai/docs/llamaindex/modules/workflows) - learn about LlamaIndexTS workflows.
-
-You can check out [the LlamaIndexTS GitHub repository](https://github.com/run-llama/LlamaIndexTS) - your feedback and contributions are welcome!

packages/create-llama/templates/components/use-cases/typescript/document_generator/src/app/workflow.ts

@@ -1,328 +0,0 @@
-import { extractLastArtifact } from "@llamaindex/server";
-import { ChatMemoryBuffer, MessageContent, Settings } from "llamaindex";
-
-import {
-  agentStreamEvent,
-  createStatefulMiddleware,
-  createWorkflow,
-  startAgentEvent,
-  stopAgentEvent,
-  workflowEvent,
-} from "@llamaindex/workflow";
-
-import { z } from "zod";
-
-export const DocumentRequirementSchema = z.object({
-  type: z.enum(["markdown", "html"]),
-  title: z.string(),
-  requirement: z.string(),
-});
-
-export type DocumentRequirement = z.infer<typeof DocumentRequirementSchema>;
-
-export const UIEventSchema = z.object({
-  type: z.literal("ui_event"),
-  data: z.object({
-    state: z
-      .enum(["plan", "generate", "completed"])
-      .describe(
-        "The current state of the workflow: 'plan', 'generate', or 'completed'.",
-      ),
-    requirement: z
-      .string()
-      .optional()
-      .describe(
-        "An optional requirement creating or updating a document, if applicable.",
-      ),
-  }),
-});
-
-export type UIEvent = z.infer<typeof UIEventSchema>;
-
-const planEvent = workflowEvent<{
-  userInput: MessageContent;
-  context?: string | undefined;
-}>();
-
-const generateArtifactEvent = workflowEvent<{
-  requirement: DocumentRequirement;
-}>();
-
-const synthesizeAnswerEvent = workflowEvent<{
-  requirement: DocumentRequirement;
-  generatedArtifact: string;
-}>();
-
-const uiEvent = workflowEvent<UIEvent>();
-
-const artifactEvent = workflowEvent<{
-  type: "artifact";
-  data: {
-    type: "document";
-    created_at: number;
-    data: {
-      title: string;
-      content: string;
-      type: "markdown" | "html";
-    };
-  };
-}>();
-
-export function workflowFactory(reqBody: any) {
-  const llm = Settings.llm;
-
-  const { withState, getContext } = createStatefulMiddleware(() => {
-    return {
-      memory: new ChatMemoryBuffer({ llm }),
-      lastArtifact: extractLastArtifact(reqBody),
-    };
-  });
-  const workflow = withState(createWorkflow());
-
-  workflow.handle([startAgentEvent], async ({ data }) => {
-    const { userInput, chatHistory = [] } = data;
-    // Prepare chat history
-    const { state } = getContext();
-    // Put user input to the memory
-    if (!userInput) {
-      throw new Error("Missing user input to start the workflow");
-    }
-    state.memory.set(chatHistory);
-    state.memory.put({ role: "user", content: userInput });
-
-    return planEvent.with({
-      userInput,
-      context: state.lastArtifact
-        ? JSON.stringify(state.lastArtifact)
-        : undefined,
-    });
-  });
-
-  workflow.handle([planEvent], async ({ data: planData }) => {
-    const { sendEvent } = getContext();
-    const { state } = getContext();
-    sendEvent(
-      uiEvent.with({
-        type: "ui_event",
-        data: {
-          state: "plan",
-        },
-      }),
-    );
-    const user_msg = planData.userInput;
-    const context = planData.context
-      ? `## The context is: \n${planData.context}\n`
-      : "";
-    const prompt = `
-         You are a documentation analyst responsible for analyzing the user's request and providing requirements for document generation or update.
-         Follow these instructions:
-         1. Carefully analyze the conversation history and the user's request to determine what has been done and what the next step should be.
-         2. From the user's request, provide requirements for the next step of the document generation or update.
-         3. Do not be verbose; only return the requirements for the next step of the document generation or update.
-         4. Only the following document types are allowed: "markdown", "html".
-         5. The requirement should be in the following format:
-            \`\`\`json
-            {
-                "type": "markdown" | "html",
-                "title": string,
-                "requirement": string
-            }
-            \`\`\`
-
-         ## Example:
-         User request: Create a project guideline document.
-         You should return:
-         \`\`\`json
-         {
-             "type": "markdown",
-             "title": "Project Guideline",
-             "requirement": "Generate a Markdown document that outlines the project goals, deliverables, and timeline. Include sections for introduction, objectives, deliverables, and timeline."
-         }
-         \`\`\`
-
-         User request: Add a troubleshooting section to the guideline.
-         You should return:
-         \`\`\`json
-         {
-             "type": "markdown",
-             "title": "Project Guideline",
-             "requirement": "Add a 'Troubleshooting' section at the end of the document with common issues and solutions."
-         }
-         \`\`\`
-
-         ${context}
-
-         Now, please plan for the user's request:
-         ${user_msg}
-        `;
-
-    const response = await llm.complete({
-      prompt,
-    });
-    // Parse the response to DocumentRequirement
-    const jsonBlock = response.text.match(/```json\s*([\s\S]*?)\s*```/);
-    if (!jsonBlock) {
-      throw new Error("No JSON block found in the response.");
-    }
-    const requirement = DocumentRequirementSchema.parse(
-      JSON.parse(jsonBlock[1]),
-    );
-    state.memory.put({
-      role: "assistant",
-      content: `Planning for the document generation: \n${response.text}`,
-    });
-    return generateArtifactEvent.with({
-      requirement,
-    });
-  });
-
-  workflow.handle(
-    [generateArtifactEvent],
-    async ({ data: { requirement } }) => {
-      const { sendEvent } = getContext();
-      const { state } = getContext();
-
-      sendEvent(
-        uiEvent.with({
-          type: "ui_event",
-          data: {
-            state: "generate",
-            requirement: requirement.requirement,
-          },
-        }),
-      );
-
-      const previousArtifact = state.lastArtifact
-        ? JSON.stringify(state.lastArtifact)
-        : "";
-      const requirementStr = JSON.stringify(requirement);
-
-      const prompt = `
-         You are a skilled technical writer who can help users with documentation.
-         You are given a task to generate or update a document for a given requirement.
-
-         ## Follow these instructions:
-         **1. Carefully read the user's requirements.**
-            If any details are ambiguous or missing, make reasonable assumptions and clearly reflect those in your output.
-            If the previous document is provided:
-            + Carefully analyze the document with the request to make the right changes.
-            + Avoid making unnecessary changes from the previous document if the request is not to rewrite it from scratch.
-         **2. For document requests:**
-            - If the user does not specify a type, default to Markdown.
-            - Ensure the document is clear, well-structured, and grammatically correct.
-            - Only generate content relevant to the user's request—do not add extra boilerplate.
-         **3. Do not be verbose in your response.**
-            - No other text or comments; only return the document content wrapped by the appropriate code block (\`\`\`markdown or \`\`\`html).
-            - If the user's request is to update the document, only return the updated document.
-         **4. Only the following types are allowed: "markdown", "html".**
-         **5. If there is no change to the document, return the reason without any code block.**
-
-         ## Example:
-         \`\`\`markdown
-         # Project Guideline
-         
-         ## Introduction
-         ...
-         \`\`\`
-
-         The previous content is:
-         ${previousArtifact}
-
-         Now, please generate the document for the following requirement:
-         ${requirementStr}
-      `;
-
-      const response = await llm.complete({
-        prompt,
-      });
-
-      // Extract the document from the response
-      const docMatch = response.text.match(/```(markdown|html)([\s\S]*)```/);
-      const generatedContent = response.text;
-
-      if (docMatch) {
-        const content = docMatch[2].trim();
-        const docType = docMatch[1] as "markdown" | "html";
-
-        // Put the generated document to the memory
-        state.memory.put({
-          role: "assistant",
-          content: `Generated document: \n${response.text}`,
-        });
-
-        // To show the Canvas panel for the artifact
-        sendEvent(
-          artifactEvent.with({
-            type: "artifact",
-            data: {
-              type: "document",
-              created_at: Date.now(),
-              data: {
-                title: requirement.title,
-                content: content,
-                type: docType,
-              },
-            },
-          }),
-        );
-      }
-
-      return synthesizeAnswerEvent.with({
-        requirement,
-        generatedArtifact: generatedContent,
-      });
-    },
-  );
-
-  workflow.handle([synthesizeAnswerEvent], async ({ data }) => {
-    const { sendEvent } = getContext();
-    const { state } = getContext();
-
-    const chatHistory = await state.memory.getMessages();
-    const messages = [
-      ...chatHistory,
-      {
-        role: "system" as const,
-        content: `
-                Your responsibility is to explain the work to the user.
-                If there is no document to update, explain the reason.
-                If the document is updated, just summarize what changed. Don't need to include the whole document again in the response.
-                `,
-      },
-    ];
-
-    const responseStream = await llm.chat({
-      messages,
-      stream: true,
-    });
-
-    sendEvent(
-      uiEvent.with({
-        type: "ui_event",
-        data: {
-          state: "completed",
-          requirement: data.requirement.requirement,
-        },
-      }),
-    );
-
-    let response = "";
-    for await (const chunk of responseStream) {
-      response += chunk.delta;
-      sendEvent(
-        agentStreamEvent.with({
-          delta: chunk.delta,
-          response: "",
-          currentAgentName: "assistant",
-          raw: chunk,
-        }),
-      );
-    }
-
-    return stopAgentEvent.with({
-      result: response,
-    });
-  });
-
-  return workflow;
-}

packages/create-llama/templates/components/use-cases/typescript/financial_report/README-template.md

@@ -1,52 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) project bootstrapped with [`create-llama`](https://github.com/run-llama/LlamaIndexTS/tree/main/packages/create-llama).
-
-## Getting Started
-
-First, install the dependencies:
-
-```
-npm install
-```
-
-Then check the parameters that have been pre-configured in the `.env` file in this directory.
-Make sure you have set the `OPENAI_API_KEY` for the LLM and the `E2B_API_KEY` for the code interpreter. You can get the E2B API key from [here](https://e2b.dev).
-
-Second, generate the embeddings of the example documents in the `./data` directory:
-
-```
-npm run generate
-```
-
-Third, run the development server:
-
-```
-npm run dev
-```
-
-Open [http://localhost:3000](http://localhost:3000) with your browser to see the chat UI.
-
-## Configure LLM and Embedding Model
-
-You can configure [LLM model](https://ts.llamaindex.ai/docs/llamaindex/modules/llms) and [embedding model](https://ts.llamaindex.ai/docs/llamaindex/modules/embeddings) in the [settings file](src/app/settings.ts).
-
-## Use Case
-
-We have prepared an [example workflow](./src/app/workflow.ts) for the financial report generation use case, where you can request for the app to generate a financial report using the example documents in the [./data](./data).
-
-You can start by sending an request on the [chat UI](http://localhost:3000) or you can test the `/api/chat` endpoint with the following curl request:
-
-```shell
-curl --location 'localhost:3000/api/chat' \
---header 'Content-Type: application/json' \
---data '{ "messages": [{ "role": "user", "content": "Generate a financial report that compares the financial performance of Apple and Tesla" }] }'
-```
-
-## Learn More
-
-To learn more about LlamaIndex, take a look at the following resources:
-
-- [LlamaIndex Documentation](https://docs.llamaindex.ai) - learn about LlamaIndex (Python features).
-- [LlamaIndexTS Documentation](https://ts.llamaindex.ai/docs/llamaindex) - learn about LlamaIndex (Typescript features).
-- [Workflows Introduction](https://ts.llamaindex.ai/docs/llamaindex/modules/workflows) - learn about LlamaIndexTS workflows.
-
-You can check out [the LlamaIndexTS GitHub repository](https://github.com/run-llama/LlamaIndexTS) - your feedback and contributions are welcome!

packages/create-llama/templates/components/use-cases/typescript/financial_report/src/app/workflow.ts

@@ -1,318 +0,0 @@
-import { toAgentRunEvent, toSourceEvent } from "@llamaindex/server";
-import {
-  callTools,
-  chatWithTools,
-  documentGenerator,
-  interpreter,
-} from "@llamaindex/tools";
-import {
-  agentStreamEvent,
-  createStatefulMiddleware,
-  createWorkflow,
-  startAgentEvent,
-  stopAgentEvent,
-  workflowEvent,
-} from "@llamaindex/workflow";
-import {
-  BaseToolWithCall,
-  ChatMemoryBuffer,
-  ChatMessage,
-  Metadata,
-  NodeWithScore,
-  Settings,
-  ToolCall,
-  ToolCallLLM,
-} from "llamaindex";
-import { getIndex } from "./data";
-
-export async function workflowFactory(reqBody: any) {
-  const index = await getIndex(reqBody?.data);
-
-  const queryEngineTool = index.queryTool({
-    metadata: {
-      name: "query_document",
-      description: `This tool can retrieve information about Apple and Tesla financial data`,
-    },
-    includeSourceNodes: true,
-  });
-
-  if (!process.env.E2B_API_KEY) {
-    throw new Error("E2B_API_KEY is required to use the code interpreter tool");
-  }
-
-  const codeInterpreterTool = interpreter({
-    apiKey: process.env.E2B_API_KEY!,
-  });
-  const documentGeneratorTool = documentGenerator();
-
-  return getWorkflow(
-    queryEngineTool,
-    codeInterpreterTool,
-    documentGeneratorTool,
-  );
-}
-
-// workflow events
-const inputEvent = workflowEvent<{ input: ChatMessage[] }>();
-const researchEvent = workflowEvent<{ toolCalls: ToolCall[] }>();
-const analyzeEvent = workflowEvent<{ input: ChatMessage | ToolCall[] }>();
-const reportGenerationEvent = workflowEvent<{ toolCalls: ToolCall[] }>();
-
-const DEFAULT_SYSTEM_PROMPT = `
-You are a financial analyst who are given a set of tools to help you.
-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.
-`;
-
-// workflow definition
-export function getWorkflow(
-  queryEngineTool: BaseToolWithCall,
-  codeInterpreterTool: BaseToolWithCall,
-  documentGeneratorTool: BaseToolWithCall,
-) {
-  const llm = Settings.llm as ToolCallLLM;
-  if (!llm.supportToolCall) {
-    throw new Error("LLM is not a ToolCallLLM");
-  }
-  const { withState, getContext } = createStatefulMiddleware(() => ({
-    memory: new ChatMemoryBuffer({ llm, chatHistory: [] }),
-  }));
-
-  const workflow = withState(createWorkflow());
-
-  // Add steps
-  workflow.handle([startAgentEvent], async ({ data }) => {
-    const { state } = getContext();
-    const { userInput, chatHistory = [] } = data;
-    if (!userInput) throw new Error("Invalid input");
-
-    state.memory.set(chatHistory);
-
-    state.memory.put({ role: "system", content: DEFAULT_SYSTEM_PROMPT });
-
-    state.memory.put({ role: "user", content: userInput });
-
-    const messages = await state.memory.getMessages();
-    return inputEvent.with({ input: messages });
-  });
-
-  workflow.handle([inputEvent], async ({ data }) => {
-    const { sendEvent, state } = getContext();
-    const chatHistory = data.input;
-
-    const tools = [codeInterpreterTool, documentGeneratorTool, queryEngineTool];
-
-    const toolCallResponse = await chatWithTools(llm, tools, chatHistory);
-
-    if (!toolCallResponse.hasToolCall()) {
-      const generator = toolCallResponse.responseGenerator;
-      let response = "";
-      if (generator) {
-        for await (const chunk of generator) {
-          response += chunk.delta;
-          sendEvent(
-            agentStreamEvent.with({
-              delta: chunk.delta,
-              response,
-              currentAgentName: "LLM", // Or derive from context if needed
-              raw: chunk.raw,
-            }),
-          );
-        }
-      }
-      return stopAgentEvent.with({ result: response });
-    }
-
-    if (toolCallResponse.hasMultipleTools()) {
-      state.memory.put({
-        role: "assistant",
-        content:
-          "Calling different tools is not allowed. Please only use multiple calls of the same tool.",
-      });
-      const newChatHistory = await state.memory.getMessages();
-      return inputEvent.with({ input: newChatHistory });
-    }
-
-    // Put the LLM tool call message into the memory
-    // And trigger the next step according to the tool call
-    if (toolCallResponse.toolCallMessage) {
-      state.memory.put(toolCallResponse.toolCallMessage);
-    }
-    const toolName = toolCallResponse.getToolNames()[0];
-    switch (toolName) {
-      case codeInterpreterTool.metadata.name:
-        return analyzeEvent.with({
-          input: toolCallResponse.toolCalls,
-        });
-      case documentGeneratorTool.metadata.name:
-        return reportGenerationEvent.with({
-          toolCalls: toolCallResponse.toolCalls,
-        });
-      default:
-        if (queryEngineTool.metadata.name === toolName) {
-          return researchEvent.with({
-            toolCalls: toolCallResponse.toolCalls,
-          });
-        }
-        throw new Error(`Unknown tool: ${toolName}`);
-    }
-  });
-
-  workflow.handle([researchEvent], async ({ data }) => {
-    const { sendEvent, state } = getContext();
-    sendEvent(
-      toAgentRunEvent({
-        agent: "Researcher",
-        text: "Researching data",
-        type: "text",
-      }),
-    );
-
-    const { toolCalls } = data;
-
-    const toolMsgs = await callTools({
-      tools: [queryEngineTool],
-      toolCalls,
-      writeEvent: (text, step) => {
-        sendEvent(
-          toAgentRunEvent({
-            agent: "Researcher",
-            text,
-            type: toolCalls.length > 1 ? "progress" : "text",
-            current: step,
-            total: toolCalls.length,
-          }),
-        );
-      },
-    });
-    for (const toolMsg of toolMsgs) {
-      state.memory.put(toolMsg);
-    }
-
-    const sourcesNodes: NodeWithScore<Metadata>[] = toolMsgs
-      .map((msg) => (msg.options as any)?.toolResult?.result?.sourceNodes)
-      .flat()
-      .filter(Boolean);
-
-    if (sourcesNodes.length > 0) {
-      sendEvent(toSourceEvent(sourcesNodes));
-    }
-
-    // Send a message indicating research is done, triggering analysis
-    return analyzeEvent.with({
-      input: {
-        role: "assistant",
-        content:
-          "I have finished researching the data, please analyze the data.",
-      },
-    });
-  });
-
-  /**
-   * Analyze a research result or a tool call for code interpreter from the LLM
-   */
-  workflow.handle([analyzeEvent], async ({ data }) => {
-    const { sendEvent, state } = getContext();
-    sendEvent(
-      toAgentRunEvent({
-        agent: "Analyst",
-        text: "Analyzing data",
-        type: "text",
-      }),
-    );
-    // Request by workflow LLM, input is a list of tool calls
-    let toolCalls: ToolCall[] = [];
-    if (Array.isArray(data.input)) {
-      toolCalls = data.input;
-    } else {
-      // Requested by Researcher, input is a ChatMessage
-      // We start new LLM chat specifically for analyzing the data
-      const analysisPrompt = `
-      You are an expert in analyzing financial data.
-      You are given a set of financial data to analyze. Your task is to analyze the financial data and return a report.
-      Your response should include a detailed analysis of the financial data, including any trends, patterns, or insights that you find.
-      Construct the analysis in textual format; including tables would be great!
-      Don't need to synthesize the data, just analyze and provide your findings.
-      `;
-
-      // Clone the current chat history
-      // Add the analysis system prompt and the message from the researcher
-      const currentChatHistory = await state.memory.getMessages();
-      const newChatHistory = [
-        ...currentChatHistory,
-        { role: "system", content: analysisPrompt },
-        data.input, // This is the ChatMessage from the research step
-      ];
-      const toolCallResponse = await chatWithTools(
-        llm,
-        [codeInterpreterTool],
-        newChatHistory as ChatMessage[],
-      );
-
-      if (!toolCallResponse.hasToolCall()) {
-        // If no tool call needed for analysis, put the response directly
-        state.memory.put(await toolCallResponse.asFullResponse());
-        const finalChatHistory = await state.memory.getMessages();
-        return inputEvent.with({ input: finalChatHistory });
-      } else {
-        state.memory.put(toolCallResponse.toolCallMessage!);
-        toolCalls = toolCallResponse.toolCalls;
-      }
-    }
-
-    // Call the code interpreter tools if needed
-    if (toolCalls.length > 0) {
-      const toolMsgs = await callTools({
-        tools: [codeInterpreterTool],
-        toolCalls,
-        writeEvent: (text, step) => {
-          sendEvent(
-            toAgentRunEvent({
-              agent: "Analyst",
-              text,
-              type: toolCalls.length > 1 ? "progress" : "text",
-              current: step,
-              total: toolCalls.length,
-            }),
-          );
-        },
-      });
-      for (const toolMsg of toolMsgs) {
-        state.memory.put(toolMsg);
-      }
-    }
-
-    const finalChatHistory = await state.memory.getMessages();
-    // After analysis (or tool calls for analysis), trigger the next LLM input cycle
-    return inputEvent.with({ input: finalChatHistory });
-  });
-
-  workflow.handle([reportGenerationEvent], async ({ data }) => {
-    const { sendEvent, state } = getContext();
-    const { toolCalls } = data;
-
-    const toolMsgs = await callTools({
-      tools: [documentGeneratorTool],
-      toolCalls,
-      writeEvent: (text, step) => {
-        sendEvent(
-          toAgentRunEvent({
-            agent: "Reporter",
-            text,
-            type: toolCalls.length > 1 ? "progress" : "text",
-            current: step,
-            total: toolCalls.length,
-          }),
-        );
-      },
-    });
-    for (const toolMsg of toolMsgs) {
-      state.memory.put(toolMsg);
-    }
-    const chatHistory = await state.memory.getMessages();
-    // After report generation, trigger the next LLM input cycle
-    return inputEvent.with({ input: chatHistory });
-  });
-
-  return workflow;
-}

packages/create-llama/templates/components/use-cases/typescript/financial_report/src/generate.ts

@@ -1,39 +0,0 @@
-import { SimpleDirectoryReader } from "@llamaindex/readers/directory";
-import "dotenv/config";
-import { storageContextFromDefaults, VectorStoreIndex } from "llamaindex";
-import { initSettings } from "./app/settings";
-
-async function generateDatasource() {
-  console.log(`Generating storage context...`);
-  // Split documents, create embeddings and store them in the storage context
-  const storageContext = await storageContextFromDefaults({
-    persistDir: "storage",
-  });
-  // load documents from current directory into an index
-  const reader = new SimpleDirectoryReader();
-  const documents = await reader.loadData("data");
-
-  await VectorStoreIndex.fromDocuments(documents, {
-    storageContext,
-  });
-  console.log("Storage context successfully generated.");
-}
-
-(async () => {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  initSettings();
-
-  if (command === "ui") {
-    console.error("This project doesn't use any custom UI.");
-    return;
-  } else {
-    if (command !== "datasource") {
-      console.error(
-        `Unrecognized command: ${command}. Generating datasource by default.`,
-      );
-    }
-    await generateDatasource();
-  }
-})();

packages/create-llama/templates/components/vectordbs/llamaindexserver/llamacloud/python/generate.py

@@ -1,53 +0,0 @@
-# flake8: noqa: E402
-
-from dotenv import load_dotenv
-
-load_dotenv()
-
-import logging
-
-from app.index import get_index
-from app.settings import init_settings
-from llama_index.server.services.llamacloud.generate import (
-    load_to_llamacloud,
-)
-
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger()
-
-
-def generate_index():
-    init_settings()
-    logger.info("Generate index for the provided data")
-
-    index = get_index(create_if_missing=True)
-    if index is None:
-        raise ValueError("Index not found and could not be created")
-
-    load_to_llamacloud(index, logger=logger)
-
-
-def generate_ui_for_workflow():
-    """
-    Generate UI for UIEventData event in app/workflow.py
-    """
-    import asyncio
-    from llama_index.llms.openai import OpenAI
-    from main import COMPONENT_DIR
-
-    # To generate UI components for additional event types,
-    # import the corresponding data model (e.g., MyCustomEventData)
-    # and run the generate_ui_for_workflow function with the imported model.
-    # Make sure the output filename of the generated UI component matches the event type (here `ui_event`)
-    try:
-        from app.workflow import UIEventData  # type: ignore
-    except ImportError:
-        raise ImportError("Couldn't generate UI component for the current workflow.")
-    from llama_index.server.gen_ui import generate_event_component
-
-    # works also well with Claude 3.7 Sonnet or Gemini Pro 2.5
-    llm = OpenAI(model="gpt-4.1")
-    code = asyncio.run(generate_event_component(event_cls=UIEventData, llm=llm))
-    with open(f"{COMPONENT_DIR}/ui_event.jsx", "w") as f:
-        f.write(code)

packages/create-llama/templates/components/vectordbs/llamaindexserver/llamacloud/python/index.py

@@ -1,7 +0,0 @@
-from llama_index.server.services.llamacloud import (
-    LlamaCloudIndex,
-    get_client,
-    get_index,
-)
-
-__all__ = ["LlamaCloudIndex", "get_client", "get_index"]

packages/create-llama/templates/components/vectordbs/llamaindexserver/llamacloud/typescript/generate.ts

@@ -1,136 +0,0 @@
-import { generateEventComponent } from "@llamaindex/server";
-import * as dotenv from "dotenv";
-import "dotenv/config";
-import * as fs from "fs/promises";
-import { LLamaCloudFileService, OpenAI } from "llamaindex";
-import * as path from "path";
-import { getIndex } from "./app/data";
-import { initSettings } from "./app/settings";
-
-dotenv.config();
-
-const REQUIRED_ENV_VARS = [
-  "LLAMA_CLOUD_INDEX_NAME",
-  "LLAMA_CLOUD_PROJECT_NAME",
-  "LLAMA_CLOUD_API_KEY",
-];
-
-export function checkRequiredEnvVars() {
-  const missingEnvVars = REQUIRED_ENV_VARS.filter((envVar) => {
-    return !process.env[envVar];
-  });
-
-  if (missingEnvVars.length > 0) {
-    console.log(
-      `The following environment variables are required but missing: ${missingEnvVars.join(
-        ", ",
-      )}`,
-    );
-    throw new Error(
-      `Missing environment variables: ${missingEnvVars.join(", ")}`,
-    );
-  }
-}
-
-async function* walk(dir: string): AsyncGenerator<string> {
-  const directory = await fs.opendir(dir);
-
-  for await (const dirent of directory) {
-    const entryPath = path.join(dir, dirent.name);
-
-    if (dirent.isDirectory()) {
-      yield* walk(entryPath); // Recursively walk through directories
-    } else if (dirent.isFile()) {
-      yield entryPath; // Yield file paths
-    }
-  }
-}
-
-async function loadAndIndex() {
-  const index = await getIndex();
-  // ensure the index is available or create a new one
-  await index.ensureIndex({
-    verbose: true,
-    embedding: {
-      type: "OPENAI_EMBEDDING",
-      component: {
-        api_key: process.env.OPENAI_API_KEY,
-        model_name: "text-embedding-3-small",
-      },
-    },
-  });
-
-  const projectId = await index.getProjectId();
-  const pipelineId = await index.getPipelineId();
-
-  // walk through the data directory and upload each file to LlamaCloud
-  for await (const filePath of walk("data")) {
-    const buffer = await fs.readFile(filePath);
-    const filename = path.basename(filePath);
-    try {
-      await LLamaCloudFileService.addFileToPipeline(
-        projectId,
-        pipelineId,
-        new File([buffer], filename),
-      );
-    } catch (error) {
-      if (
-        error instanceof ReferenceError &&
-        error.message.includes("File is not defined")
-      ) {
-        throw new Error(
-          "File class is not supported in the current Node.js version. Please use Node.js 20 or higher.",
-        );
-      }
-      throw error;
-    }
-  }
-
-  console.log(`Successfully uploaded documents to LlamaCloud!`);
-}
-
-async function generateDatasource() {
-  try {
-    checkRequiredEnvVars();
-    initSettings();
-    await loadAndIndex();
-    console.log("Finished generating storage.");
-  } catch (error) {
-    console.error("Error generating storage.", error);
-  }
-}
-
-async function generateUi() {
-  // Also works well with Claude 3.5 Sonnet and Google Gemini 2.5 Pro
-  const llm = new OpenAI({ model: "gpt-4.1" });
-
-  const workflowModule = await import("./app/workflow");
-  const UIEventSchema = (workflowModule as any).UIEventSchema;
-  if (!UIEventSchema) {
-    throw new Error(
-      "To generate the UI, you must define a UIEventSchema in your workflow.",
-    );
-  }
-
-  const generatedCode = await generateEventComponent(UIEventSchema, llm);
-  // Write the generated code to components/ui_event.ts
-  await fs.writeFile("components/ui_event.jsx", generatedCode);
-}
-
-(async () => {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  initSettings();
-
-  if (command === "datasource") {
-    await generateDatasource();
-  } else if (command === "ui") {
-    await generateUi();
-  } else {
-    console.error(
-      'Invalid command. Please use "datasource" or "ui". Running "datasource" by default.',
-    );
-    await generateDatasource(); // Default behavior or could throw an error
-  }
-})();

packages/create-llama/templates/components/vectordbs/llamaindexserver/llamacloud/typescript/index.ts

@@ -1,28 +0,0 @@
-import { LlamaCloudIndex } from "llamaindex";
-
-type LlamaCloudDataSourceParams = {
-  llamaCloudPipeline?: {
-    project: string;
-    pipeline: string;
-  };
-};
-
-export async function getIndex(params?: LlamaCloudDataSourceParams) {
-  const { project, pipeline } = params?.llamaCloudPipeline ?? {};
-  const projectName = project ?? process.env.LLAMA_CLOUD_PROJECT_NAME;
-  const pipelineName = pipeline ?? process.env.LLAMA_CLOUD_INDEX_NAME;
-  const apiKey = process.env.LLAMA_CLOUD_API_KEY;
-  if (!projectName || !pipelineName || !apiKey) {
-    throw new Error(
-      "LlamaCloud is not configured. Please set project, pipeline, and api key in the params or as environment variables.",
-    );
-  }
-  const index = new LlamaCloudIndex({
-    organizationId: process.env.LLAMA_CLOUD_ORGANIZATION_ID,
-    name: pipelineName,
-    projectName,
-    apiKey,
-    baseUrl: process.env.LLAMA_CLOUD_BASE_URL,
-  });
-  return index;
-}