review fixes

fix: use cli framework in CLI
Merge branch 'main' into ms/simplify
2026-07-02 19:14:28 -04:00 · 2024-10-14 12:34:06 +07:00 · 2024-10-14 12:27:53 +07:00 · 2024-10-14 12:08:45 +07:00 · 2024-10-14 12:05:49 +07:00 · 2024-10-14 12:03:03 +07:00
625 changed files with 7019 additions and 43631 deletions
@@ -0,0 +1,5 @@
+---
+"create-llama": patch
+---
+
+docs: chroma env variables
@@ -1,13 +1,12 @@
-name: E2E Tests for create-llama package
+name: E2E Tests
 on:
  push:
    branches: [main]
-    paths-ignore:
-      - "python/llama-index-server/**"
  pull_request:
    branches: [main]
-    paths-ignore:
-      - "python/llama-index-server/**"
+
+env:
+  POETRY_VERSION: "1.6.1"

 jobs:
  e2e-python:
@@ -33,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

@@ -51,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
@@ -68,16 +67,13 @@ jobs:
          LLAMA_CLOUD_API_KEY: ${{ secrets.LLAMA_CLOUD_API_KEY }}
          FRAMEWORK: ${{ matrix.frameworks }}
          DATASOURCE: ${{ matrix.datasources }}
-          PYTHONIOENCODING: utf-8
-          PYTHONLEGACYWINDOWSSTDIO: utf-8
-        working-directory: packages/create-llama
+        working-directory: .

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

  e2e-typescript:
@@ -86,11 +82,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"]
-        datasources: ["--no-files", "--example-file", "--llamacloud"]
+        frameworks: ["nextjs", "express"]
+        datasources: ["--no-files", "--example-file"]
    defaults:
      run:
        shell: bash
@@ -103,10 +99,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

@@ -121,15 +117,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 TypeScript
        run: pnpm run e2e:typescript
@@ -138,12 +134,11 @@ jobs:
          LLAMA_CLOUD_API_KEY: ${{ secrets.LLAMA_CLOUD_API_KEY }}
          FRAMEWORK: ${{ matrix.frameworks }}
          DATASOURCE: ${{ matrix.datasources }}
-        working-directory: packages/create-llama
+        working-directory: .

-      - uses: actions/upload-artifact@v4
+      - uses: actions/upload-artifact@v3
        if: always()
        with:
-          name: playwright-report-typescript-${{ matrix.os }}-${{ matrix.frameworks }}-${{ matrix.datasources }}-node${{ matrix.node-version }}
-          path: packages/create-llama/playwright-report/
-          overwrite: true
+          name: playwright-report-typescript
+          path: ./playwright-report/
          retention-days: 30
@@ -35,10 +35,8 @@ jobs:
        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"
@@ -1,130 +0,0 @@
-name: Release llama-index-server
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - "python/llama-index-server/**"
-      - ".github/workflows/release_llama_index_server.yml"
-  pull_request:
-    types:
-      - closed
-
-concurrency: ${{ github.workflow }}-${{ github.ref }}
-
-jobs:
-  release:
-    name: Create Release PR
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./python/llama-index-server
-    if: |
-      github.event_name == 'push' && 
-      !startsWith(github.ref, 'refs/heads/release/llama-index-server-v')
-
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Install Poetry
-        run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-
-      - name: Install dependencies
-        run: poetry install
-
-      - name: Setup Git
-        run: |
-          git config --global user.email "github-actions[bot]@users.noreply.github.com"
-          git config --global user.name "github-actions[bot]"
-
-      - name: Bump patch version
-        run: |
-          poetry version patch
-          git add pyproject.toml
-          git commit -m "chore(release): bump version to $(poetry version -s)"
-
-      - name: Get current version
-        id: get_version
-        run: |
-          version=$(poetry version -s)
-          echo "current_version=${version}" >> "$GITHUB_OUTPUT"
-
-      - name: Create Release PR
-        uses: peter-evans/create-pull-request@v6
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          commit-message: "Release: llama-index-server v${{ steps.get_version.outputs.current_version }}"
-          title: "Release: llama-index-server v${{ steps.get_version.outputs.current_version }}"
-          body: |
-            This PR was automatically created to release a new version of the llama-index-server package.
-
-            Version: ${{ steps.get_version.outputs.current_version }}
-
-            Please review the changes and merge to trigger the release.
-          branch: release/llama-index-server-v${{ steps.get_version.outputs.current_version }}
-          base: main
-          labels: release, llama-index-server
-
-  publish:
-    name: Publish to PyPI
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: ./python/llama-index-server
-    if: |
-      github.event_name == 'pull_request' && 
-      github.event.pull_request.merged == true && 
-      startsWith(github.event.pull_request.title, 'Release: llama-index-server') &&
-      startsWith(github.event.pull_request.head.ref, 'release/llama-index-server-v')
-
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Install Poetry
-        run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-
-      - name: Install dependencies
-        run: poetry install
-
-      - name: Get current version
-        id: get_version
-        run: |
-          version=$(poetry version -s)
-          echo "current_version=${version}" >> "$GITHUB_OUTPUT"
-
-      - name: Build and publish to PyPI
-        uses: JRubics/poetry-publish@v2.1
-        with:
-          python_version: "3.11"
-          pypi_token: ${{ secrets.PYPI_TOKEN }}
-          package_directory: "python/llama-index-server"
-          poetry_install_options: "--without dev"
-
-      - name: Create GitHub Release
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: llama-index-server-v${{ steps.get_version.outputs.current_version }}
-          name: "llama-index-server v${{ steps.get_version.outputs.current_version }}"
-          body: |
-            Release of llama-index-server v${{ steps.get_version.outputs.current_version }}
-          draft: false
-          prerelease: false
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -1,111 +0,0 @@
-name: Build Package
-
-on:
-  pull_request:
-
-env:
-  POETRY_VERSION: "1.8.3"
-  PYTHON_VERSION: "3.9"
-
-jobs:
-  unit-test:
-    name: Unit Tests
-    runs-on: ${{ matrix.os }}
-    defaults:
-      run:
-        working-directory: python/llama-index-server
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest]
-        python-version: ["3.9"]
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install Poetry
-        run: pipx install poetry==${{ env.POETRY_VERSION }}
-
-      - name: Set up python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-          cache: "poetry"
-
-      - name: Configure Poetry
-        run: |
-          poetry config virtualenvs.create true
-          poetry config virtualenvs.in-project true
-          poetry env use python
-
-      - name: Install dependencies
-        shell: bash
-        run: poetry install --with dev
-
-      - name: Run unit tests
-        shell: bash
-        run: |
-          poetry run pytest tests
-
-  type-check:
-    name: Type Check
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: python/llama-index-server
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install Poetry
-        run: pipx install poetry==${{ env.POETRY_VERSION }}
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-          cache: "poetry"
-
-      - name: Configure Poetry
-        run: |
-          poetry config virtualenvs.create true
-          poetry config virtualenvs.in-project true
-          poetry env use python
-
-      - name: Install dependencies
-        shell: bash
-        run: poetry install --with dev
-
-      - name: Run mypy
-        shell: bash
-        run: poetry run mypy llama_index
-
-  build:
-    needs: [unit-test, type-check]
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: python/llama-index-server
-    steps:
-      - uses: actions/checkout@v4
-      - name: Install Poetry
-        run: pipx install poetry==${{ env.POETRY_VERSION }}
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ env.PYTHON_VERSION }}
-      - name: Clear python cache
-        shell: bash
-        run: poetry cache clear --all pypi
-      - name: Build package
-        shell: bash
-        run: poetry build
-      - name: Test installing built package
-        shell: bash
-        run: python -m pip install .
-      - name: Test import
-        shell: bash
-        working-directory: ${{ vars.RUNNER_TEMP }}
-        run: python -c "from llama_index.server import LlamaIndexServer"
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: llama-index-server
-          path: python/llama-index-server/dist/
@@ -6,6 +6,9 @@ node_modules
 .pnpm-store
 .pnp.js

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

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

-# vscode
-.vscode
-!.vscode/settings.json
+# Python
+.mypy_cache/
+
+# build artifacts
+create-llama-*.tgz
@@ -1,3 +1,3 @@
 pnpm format
 pnpm lint
-uvx ruff format --check packages/create-llama/templates/
+uvx ruff format --check templates/
@@ -1,295 +1,5 @@
 # create-llama

-## 0.5.11
-
-### Patch Changes
-
- 3960618: chore: create-llama monorepo
- 8fe5fc2: chore: add llamaindex server package
-
-## 0.5.10
-
-### Patch Changes
-
- 0a2e12a: Use uv as the default package manager
-
-## 0.5.9
-
-### Patch Changes
-
- 4bc53ac: Bump new chat ui and update deep research component
- 4bc53ac: Support generate UI for deep research use case (Typescript)
-
-## 0.5.8
-
-### Patch Changes
-
- 765181a: chore: test typescript e2e with node 20 and 22
-
-## 0.5.7
-
-### Patch Changes
-
- 5988657: chore: bump llmaindex
-
-## 0.5.6
-
-### Patch Changes
-
- d363ced: Bump llamaindex server packages
-
-## 0.5.5
-
-### Patch Changes
-
- ee85320: The default custom deep research component does not work.
-
-## 0.5.4
-
-### Patch Changes
-
- 7c3b279: Support code generation of event components using an LLM (Python)
-
-## 0.5.3
-
-### Patch Changes
-
- 76ec360: Update templates to use new chat ui config
-
-## 0.5.2
-
-### Patch Changes
-
- c9f8f8d: Use custom component for deep research use case
-
-## 0.5.1
-
-### Patch Changes
-
- 08b3e07: Simplify the local index code.
-
-## 0.5.0
-
-### Minor Changes
-
- 54c9e2f: Simplified generated code using LlamaIndexServer
-
-### Patch Changes
-
- 0e4ecfa: fix: add trycatch for generating error
- ee69ce7: bump: chat-ui and tailwind v4
-
-## 0.4.0
-
-### Minor Changes
-
- 61204a1: chore: bump LITS 0.9
-
-### Patch Changes
-
- 9e723c3: Standardize the code of the workflow use case (Python)
- d5da55b: feat: add components.json to use CLI
- c1552eb: chore: move wikipedia tool to create-llama
-
-## 0.3.28
-
-### Patch Changes
-
- 4e06714: Fix the error: Unable to view file sources due to CORS.
-
-## 0.3.27
-
-### Patch Changes
-
- b4e41aa: Add deep research over own documents use case (Python)
-
-## 0.3.26
-
-### Patch Changes
-
- f73d46b: Fix missing copy of the multiagent code
-
-## 0.3.25
-
-### Patch Changes
-
- 5450096: bump: react 19 stable
-
-## 0.3.24
-
-### Patch Changes
-
- a84743c: Change --agents paramameter to --use-case
- a84743c: Add LlamaCloud support for Reflex templates
- a7a6592: Fix the npm issue on the full-stack Python template
- fc5e56e: bump: code interpreter v1
-
-## 0.3.23
-
-### Patch Changes
-
- 9077cae: Add contract review use case (Python)
-
-## 0.3.22
-
-### Patch Changes
-
- 25667d4: Make OpenAPI spec usable by custom GPTs
-
-## 0.3.21
-
-### Patch Changes
-
- 95227a7: Add query endpoint
-
-## 0.3.20
-
-### Patch Changes
-
- 27d2499: Bump the LlamaCloud library and fix breaking changes (Python).
-
-## 0.3.19
-
-### Patch Changes
-
- f9a057d: Add support multimodal indexes (e.g. from LlamaCloud)
- aedd73d: bump: chat-ui
-
-## 0.3.18
-
-### Patch Changes
-
- fe90a7e: chore: bump ai v4
- 02b2473: Show streaming errors in Python, optimize system prompts for tool usage and set the weather tool as default for the Agentic RAG use case
- 63e961e: Use auto_routed retriever mode for LlamaCloudIndex
-
-## 0.3.17
-
-### Patch Changes
-
- 28c8808: Add fly.io deployment
- 0a7dfcf: Generate NEXT_PUBLIC_CHAT_API for NextJS backend to specify alternative backend
-
-## 0.3.16
-
-### Patch Changes
-
- 8b371d8: Set pydantic version to <2.10 to avoid incompatibility with llama-index.
- 30fe269: Deactive duckduckgo tool for TS
- 30fe269: Replace DuckDuckGo by Wikipedia tool for agentic template
-
-## 0.3.15
-
-### Patch Changes
-
- fc5b266: Improve DX for Python template (use one deployment instead of two)
- f8f97d2: Add support for python 3.13
-
-## 0.3.14
-
-### Patch Changes
-
- 00f0b3a: fix: dont include user message in chat history
- 4663dec: chore: bump react19 rc
- 44b34fb: chore: update eslint 9, nextjs 15, react 19
- 6925676: feat: use latest chat UI
-
-## 0.3.13
-
-### Patch Changes
-
- 282eaa0: Ensure that the index and document store are created when uploading a file with no available index.
-
-## 0.3.12
-
-### Patch Changes
-
- 6edea6a: Optimize generated workflow code for Python
- 8431b78: Optimize Typescript multi-agent code
- 8431b78: Add form filling use case (Typescript)
-
-## 0.3.11
-
-### Patch Changes
-
- 2b8aaa8: Add support for local models via Hugging Face
- b9570b2: Fix: use generic LLMAgent instead of OpenAIAgent (adds support for Gemini and Anthropic for Agentic RAG)
- 1fe21f8: Fix the highlight.js issue with the Next.js static build
- 00009ae: feat: import pdf css
-
-## 0.3.10
-
-### Patch Changes
-
- 9172fed: feat: bump LITS 0.8.2
- 78ccde7: feat: use llamaindex chat-ui for nextjs frontend
-
-## 0.3.9
-
-### Patch Changes
-
- ed59927: Add form filling use case (Python)
-
-## 0.3.8
-
-### Patch Changes
-
- 4a83469: Add multi-agent financial report for Typescript (and update LITS to 0.7.10)
-
-## 0.3.7
-
-### Patch Changes
-
- fa80378: DocumentInfo working with relative URLs
-
-## 0.3.6
-
-### Patch Changes
-
- 0182368: Fix the streaming issue to prevent the UI from hanging.
-
-## 0.3.5
-
-### Patch Changes
-
- 2209409: Add financial report as the default use case in the multi-agent template (Python).
-
-## 0.3.4
-
-### Patch Changes
-
- 384a136: Fix import error if the artifact tool is selected
-
-## 0.3.3
-
-### Patch Changes
-
- 99b8247: Simplify and unify handling file uploads
-
-## 0.3.2
-
-### Patch Changes
-
- 6d1b6b9: Update README.md for pro mode
-
-## 0.3.1
-
-### Patch Changes
-
- f3577c5: Fix event streaming is blocked
- f3577c5: Add upload file to sandbox (artifact and code interpreter)
-
-## 0.3.0
-
-### Minor Changes
-
- 7562cb4: Simplified default questions and added pro mode
-
-### Patch Changes
-
- 0a69fe0: fix: missing params when init Astra vectorstore
- 98a82b0: docs: chroma env variables
-
 ## 0.2.19

 ### Patch Changes
@@ -12,7 +12,7 @@ npx create-llama@latest

 to get started, or watch this video for a demo session:

-<img src="https://github.com/user-attachments/assets/c4a7fe18-8e30-498a-96f8-78127dd706b9" width="100%">
+https://github.com/user-attachments/assets/dd3edc36-4453-4416-91c2-d24326c6c167

 Once your app is generated, run

@@ -24,14 +24,14 @@ to start the development server. You can then visit [http://localhost:3000](http

 ## What you'll get

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

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

 ## Using your data

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

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

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

@@ -55,9 +55,13 @@ 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
 ```

+## Want a front-end?
+
+Optionally generate a frontend if you've selected the Python or Express back-ends. If you do so, `create-llama` will generate two folders: `frontend`, for your Next.js-based frontend code, and `backend` containing your API.
+
 ## Customizing the AI models

 The app will default to OpenAI's `gpt-4o-mini` LLM and `text-embedding-3-large` embedding model.
@@ -90,51 +94,50 @@ Need to install the following packages:
  create-llama@latest
 Ok to proceed? (y) y
 ✔ What is your project named? … my-app
-✔ What app do you want to build? › Agentic RAG
-✔ What language do you want to use? › Python (FastAPI)
-✔ Do you want to use LlamaCloud services? … No / Yes
-✔ Please provide your LlamaCloud API key (leave blank to skip): …
+✔ Which template would you like to use? › Agentic RAG (e.g. chat with docs)
+✔ Which framework would you like to use? › NextJS
+✔ Would you like to set up observability? › No
 ✔ Please provide your OpenAI API key (leave blank to skip): …
+✔ Which data source would you like to use? › Use an example PDF
+✔ Would you like to add another data source? › No
+✔ Would you like to use LlamaParse (improved parser for RAG - requires API key)? … no / yes
+✔ Would you like to use a vector database? › No, just store the data in the file system
+✔ Would you like to build an agent using tools? If so, select the tools here, otherwise just press enter › Weather
 ? How would you like to proceed? › - Use arrow-keys. Return to submit.
-    Just generate code (~1 sec)
-❯   Start in VSCode (~1 sec)
-    Generate code and install dependencies (~2 min)
+   Just generate code (~1 sec)
+❯  Start in VSCode (~1 sec)
+   Generate code and install dependencies (~2 min)
+   Generate code, install dependencies, and run the app (~2 min)
 ```

 ### Running non-interactively

 You can also pass command line arguments to set up a new project
-non-interactively. For a list of the latest options, call `create-llama --help`.
+non-interactively. See `create-llama --help`:

-### Running in pro mode
+```bash
+create-llama <project-directory> [options]

-If you prefer more advanced customization options, you can run `create-llama` in pro mode using the `--pro` flag.
+Options:
+  -V, --version                      output the version number

-In pro mode, instead of selecting a predefined use case, you'll be prompted to select each technical component of your project. This allows for greater flexibility in customizing your project, including:
+  --use-npm

- **Vector Store**: Choose from a variety of vector stores for keeping your documents, including MongoDB, Pinecone, Weaviate, Qdrant and Chroma.
- **Tools**: Choose from a variety of agent tools (functions called by the LLM), such as:
-  - Code Interpreter: Executes Python code in a secure Jupyter notebook environment
-  - Artifact Code Generator: Generates code artifacts that can be run in a sandbox
-  - OpenAPI Action: Facilitates requests to a provided OpenAPI schema
-  - Image Generator: Creates images based on text descriptions
-  - Web Search: Performs web searches to retrieve up-to-date information
- **Data Sources**: Integrate various data sources into your chat application, including local files, websites, or database-retrieved data.
- **Backend Options**: Besides using Next.js or FastAPI, you can also select to use Express for a more traditional Node.js application.
- **Observability**: Choose from a variety of LLM observability tools, including LlamaTrace and Traceloop.
+    Explicitly tell the CLI to bootstrap the app using npm

-Pro mode is ideal for developers who want fine-grained control over their project's configuration and are comfortable with more technical setup options.
+  --use-pnpm
+
+    Explicitly tell the CLI to bootstrap the app using pnpm
+
+  --use-yarn
+
+    Explicitly tell the CLI to bootstrap the app using Yarn
+
+```

 ## LlamaIndex Documentation

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

-## LlamaIndex Server
-
-The generated code is using the LlamaIndex Server, which serves LlamaIndex Workflows and Agent Workflows via an API server. See the following docs for more information:
-
- [LlamaIndex Server For TypeScript](./packages/server/README.md)
- [LlamaIndex Server For Python](./python/llama-index-server/README.md)
-
 Inspired by and adapted from [create-next-app](https://github.com/vercel/next.js/tree/canary/packages/create-next-app)
@@ -7,16 +7,17 @@ import { getOnline } from "./helpers/is-online";
 import { isWriteable } from "./helpers/is-writeable";
 import { makeDir } from "./helpers/make-dir";

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

 export type InstallAppArgs = Omit<
  InstallTemplateArgs,
-  "appName" | "root" | "isOnline" | "port"
+  "appName" | "root" | "isOnline" | "customApiPath"
 > & {
  appPath: string;
  frontend: boolean;
@@ -34,12 +35,12 @@ export async function createApp({
  communityProjectConfig,
  llamapack,
  vectorDb,
+  externalPort,
  postInstallAction,
  dataSources,
  tools,
  useLlamaParse,
  observability,
-  useCase,
 }: InstallAppArgs): Promise<void> {
  const root = path.resolve(appPath);

@@ -79,30 +80,39 @@ export async function createApp({
    communityProjectConfig,
    llamapack,
    vectorDb,
+    externalPort,
    postInstallAction,
    dataSources,
    tools,
    useLlamaParse,
    observability,
-    useCase,
  };

-  // Install backend
-  await installTemplate({ ...args, backend: true });
-
-  if (frontend && framework === "fastapi" && template !== "llamaindexserver") {
+  if (frontend) {
+    // install backend
+    const backendRoot = path.join(root, "backend");
+    await makeDir(backendRoot);
+    await installTemplate({ ...args, root: backendRoot, backend: true });
    // install frontend
-    const frontendRoot = path.join(root, ".frontend");
+    const frontendRoot = path.join(root, "frontend");
    await makeDir(frontendRoot);
    await installTemplate({
      ...args,
      root: frontendRoot,
      framework: "nextjs",
+      customApiPath: `http://localhost:${externalPort ?? 8000}/api/chat`,
      backend: false,
    });
+    // copy readme for fullstack
+    await fs.promises.copyFile(
+      path.join(templatesDir, "README-fullstack.md"),
+      path.join(root, "README.md"),
+    );
+  } else {
+    await installTemplate({ ...args, backend: true });
  }

-  await configVSCode(root, templatesDir, framework);
+  await writeDevcontainer(root, templatesDir, framework, frontend);

  process.chdir(root);
  if (tryGitInit(root)) {
@@ -110,7 +120,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(
@@ -63,6 +63,7 @@ if (
            vectorDb,
            tools: "none",
            port: 3000,
+            externalPort: 8000,
            postInstallAction: "none",
            templateUI: undefined,
            appType: "--no-frontend",
@@ -100,6 +101,7 @@ if (
            vectorDb: "none",
            tools: tool,
            port: 3000,
+            externalPort: 8000,
            postInstallAction: "none",
            templateUI: undefined,
            appType: "--no-frontend",
@@ -133,6 +135,7 @@ if (
            vectorDb: "none",
            tools: "none",
            port: 3000,
+            externalPort: 8000,
            postInstallAction: "none",
            templateUI: undefined,
            appType: "--no-frontend",
@@ -166,6 +169,7 @@ if (
            vectorDb: "none",
            tools: "none",
            port: 3000,
+            externalPort: 8000,
            postInstallAction: "none",
            templateUI: undefined,
            appType: "--no-frontend",
@@ -195,47 +199,32 @@ async function createAndCheckLlamaProject({
  const pyprojectPath = path.join(projectPath, "pyproject.toml");
  expect(fs.existsSync(pyprojectPath)).toBeTruthy();

-  // Modify environment for the command
-  const commandEnv = {
+  const env = {
    ...process.env,
+    POETRY_VIRTUALENVS_IN_PROJECT: "true",
  };

-  console.log("Running uv venv...");
+  // Run poetry install
  try {
-    const { stdout: venvStdout, stderr: venvStderr } = await execAsync(
-      "uv venv",
-      { cwd: projectPath, env: commandEnv },
+    const { stdout: installStdout, stderr: installStderr } = await execAsync(
+      "poetry install",
+      { cwd: projectPath, env },
    );
-    console.log("uv venv stdout:", venvStdout);
-    console.error("uv venv stderr:", venvStderr);
+    console.log("poetry install stdout:", installStdout);
+    console.error("poetry install stderr:", installStderr);
  } catch (error) {
-    console.error("Error running uv venv:", error);
-    throw error; // Re-throw error to fail the test
+    console.error("Error running poetry install:", error);
+    throw error;
  }

-  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 ....");
+  // Run poetry run mypy
  try {
    const { stdout: mypyStdout, stderr: mypyStderr } = await execAsync(
-      "uv run mypy .",
-      { cwd: projectPath, env: commandEnv },
+      "poetry run mypy .",
+      { cwd: projectPath, env },
    );
-    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
+    console.log("poetry run mypy stdout:", mypyStdout);
+    console.error("poetry run mypy stderr:", mypyStderr);
  } catch (error) {
    console.error("Error running mypy:", error);
    throw error;
@@ -0,0 +1,63 @@
+/* eslint-disable turbo/no-undeclared-env-vars */
+import { expect, test } from "@playwright/test";
+import { ChildProcess } from "child_process";
+import fs from "fs";
+import path from "path";
+import { TemplateFramework } from "../../helpers";
+import { createTestDir, runCreateLlama } from "../utils";
+
+const templateFramework: TemplateFramework = process.env.FRAMEWORK
+  ? (process.env.FRAMEWORK as TemplateFramework)
+  : "fastapi";
+const dataSource: string = process.env.DATASOURCE
+  ? process.env.DATASOURCE
+  : "--example-file";
+
+// The extractor template currently only works with FastAPI and files (and not on Windows)
+if (
+  process.platform !== "win32" &&
+  templateFramework === "fastapi" &&
+  dataSource === "--example-file"
+) {
+  test.describe("Test extractor template", async () => {
+    let frontendPort: number;
+    let backendPort: number;
+    let name: string;
+    let appProcess: ChildProcess;
+    let cwd: string;
+
+    // Create extractor app
+    test.beforeAll(async () => {
+      cwd = await createTestDir();
+      frontendPort = Math.floor(Math.random() * 10000) + 10000;
+      backendPort = frontendPort + 1;
+      const result = await runCreateLlama({
+        cwd,
+        templateType: "extractor",
+        templateFramework: "fastapi",
+        dataSource: "--example-file",
+        vectorDb: "none",
+        port: frontendPort,
+        externalPort: backendPort,
+        postInstallAction: "runApp",
+      });
+      name = result.projectName;
+      appProcess = result.appProcess;
+    });
+
+    test.afterAll(async () => {
+      appProcess.kill();
+    });
+
+    test("App folder should exist", async () => {
+      const dirExists = fs.existsSync(path.join(cwd, name));
+      expect(dirExists).toBeTruthy();
+    });
+    test("Frontend should have a title", async ({ page }) => {
+      await page.goto(`http://localhost:${frontendPort}`);
+      await expect(page.getByText("Built by LlamaIndex")).toBeVisible({
+        timeout: 2000 * 60,
+      });
+    });
+  });
+}
@@ -0,0 +1,85 @@
+/* eslint-disable turbo/no-undeclared-env-vars */
+import { expect, test } from "@playwright/test";
+import { ChildProcess } from "child_process";
+import fs from "fs";
+import path from "path";
+import type {
+  TemplateFramework,
+  TemplatePostInstallAction,
+  TemplateUI,
+} from "../../helpers";
+import { createTestDir, runCreateLlama, type AppType } from "../utils";
+
+const templateFramework: TemplateFramework = process.env.FRAMEWORK
+  ? (process.env.FRAMEWORK as TemplateFramework)
+  : "fastapi";
+const dataSource: string = "--example-file";
+const templateUI: TemplateUI = "shadcn";
+const templatePostInstallAction: TemplatePostInstallAction = "runApp";
+const appType: AppType = templateFramework === "nextjs" ? "" : "--frontend";
+const userMessage = "Write a blog post about physical standards for letters";
+
+test.describe(`Test multiagent template ${templateFramework} ${dataSource} ${templateUI} ${appType} ${templatePostInstallAction}`, async () => {
+  test.skip(
+    process.platform !== "linux" || process.env.DATASOURCE === "--no-files",
+    "The multiagent template currently only works with files. We also only run on Linux to speed up tests.",
+  );
+  let port: number;
+  let externalPort: number;
+  let cwd: string;
+  let name: string;
+  let appProcess: ChildProcess;
+  // Only test without using vector db for now
+  const vectorDb = "none";
+
+  test.beforeAll(async () => {
+    port = Math.floor(Math.random() * 10000) + 10000;
+    externalPort = port + 1;
+    cwd = await createTestDir();
+    const result = await runCreateLlama({
+      cwd,
+      templateType: "multiagent",
+      templateFramework,
+      dataSource,
+      vectorDb,
+      port,
+      externalPort,
+      postInstallAction: templatePostInstallAction,
+      templateUI,
+      appType,
+    });
+    name = result.projectName;
+    appProcess = result.appProcess;
+  });
+
+  test("App folder should exist", async () => {
+    const dirExists = fs.existsSync(path.join(cwd, name));
+    expect(dirExists).toBeTruthy();
+  });
+
+  test("Frontend should have a title", async ({ page }) => {
+    await page.goto(`http://localhost:${port}`);
+    await expect(page.getByText("Built by LlamaIndex")).toBeVisible();
+  });
+
+  test("Frontend should be able to submit a message and receive the start of a streamed response", async ({
+    page,
+  }) => {
+    await page.goto(`http://localhost:${port}`);
+    await page.fill("form textarea", userMessage);
+
+    const responsePromise = page.waitForResponse((res) =>
+      res.url().includes("/api/chat"),
+    );
+
+    await page.click("form button[type=submit]");
+
+    const response = await responsePromise;
+    expect(response.ok()).toBeTruthy();
+  });
+
+  // clean processes
+  test.afterAll(async () => {
+    appProcess?.kill();
+  });
+});
@@ -22,7 +22,7 @@ const templatePostInstallAction: TemplatePostInstallAction = "runApp";
 const llamaCloudProjectName = "create-llama";
 const llamaCloudIndexName = "e2e-test";

-const appType: AppType = templateFramework === "fastapi" ? "--frontend" : "";
+const appType: AppType = templateFramework === "nextjs" ? "" : "--frontend";
 const userMessage =
  dataSource !== "--no-files" ? "Physical standard for letters" : "Hello";

@@ -35,6 +35,7 @@ test.describe(`Test streaming template ${templateFramework} ${dataSource} ${temp
  }

  let port: number;
+  let externalPort: number;
  let cwd: string;
  let name: string;
  let appProcess: ChildProcess;
@@ -43,6 +44,7 @@ test.describe(`Test streaming template ${templateFramework} ${dataSource} ${temp

  test.beforeAll(async () => {
    port = Math.floor(Math.random() * 10000) + 10000;
+    externalPort = port + 1;
    cwd = await createTestDir();
    const result = await runCreateLlama({
      cwd,
@@ -51,6 +53,7 @@ test.describe(`Test streaming template ${templateFramework} ${dataSource} ${temp
      dataSource,
      vectorDb,
      port,
+      externalPort,
      postInstallAction: templatePostInstallAction,
      templateUI,
      appType,
@@ -65,11 +68,8 @@ test.describe(`Test streaming template ${templateFramework} ${dataSource} ${temp
    const dirExists = fs.existsSync(path.join(cwd, name));
    expect(dirExists).toBeTruthy();
  });
-
  test("Frontend should have a title", async ({ page }) => {
-    test.skip(
-      templatePostInstallAction !== "runApp" || templateFramework === "express",
-    );
+    test.skip(templatePostInstallAction !== "runApp");
    await page.goto(`http://localhost:${port}`);
    await expect(page.getByText("Built by LlamaIndex")).toBeVisible();
  });
@@ -77,9 +77,7 @@ test.describe(`Test streaming template ${templateFramework} ${dataSource} ${temp
  test("Frontend should be able to submit a message and receive a response", async ({
    page,
  }) => {
-    test.skip(
-      templatePostInstallAction !== "runApp" || templateFramework === "express",
-    );
+    test.skip(templatePostInstallAction !== "runApp");
    await page.goto(`http://localhost:${port}`);
    await page.fill("form textarea", userMessage);
    const [response] = await Promise.all([
@@ -104,7 +102,7 @@ test.describe(`Test streaming template ${templateFramework} ${dataSource} ${temp
    test.skip(templatePostInstallAction !== "runApp");
    test.skip(templateFramework === "nextjs");
    const response = await request.post(
-      `http://localhost:${port}/api/chat/request`,
+      `http://localhost:${externalPort}/api/chat/request`,
      {
        data: {
          messages: [
@@ -56,6 +56,7 @@ test.describe("Test resolve TS dependencies", () => {
      dataSource: dataSource,
      vectorDb: vectorDb,
      port: 3000,
+      externalPort: 8000,
      postInstallAction: "none",
      templateUI: undefined,
      appType: templateFramework === "nextjs" ? "" : "--no-frontend",
@@ -74,7 +75,7 @@ test.describe("Test resolve TS dependencies", () => {
    // Install dependencies using pnpm
    try {
      const { stderr: installStderr } = await execAsync(
-        "pnpm install --prefer-offline --ignore-workspace",
+        "pnpm install --prefer-offline",
        {
          cwd: appDir,
        },
@@ -25,6 +25,7 @@ export type RunCreateLlamaOptions = {
  dataSource: string;
  vectorDb: TemplateVectorDB;
  port: number;
+  externalPort: number;
  postInstallAction: TemplatePostInstallAction;
  templateUI?: TemplateUI;
  appType?: AppType;
@@ -33,7 +34,6 @@ export type RunCreateLlamaOptions = {
  tools?: string;
  useLlamaParse?: boolean;
  observability?: string;
-  useCase?: string;
 };

 export async function runCreateLlama({
@@ -43,6 +43,7 @@ export async function runCreateLlama({
  dataSource,
  vectorDb,
  port,
+  externalPort,
  postInstallAction,
  templateUI,
  appType,
@@ -51,7 +52,6 @@ export async function runCreateLlama({
  tools,
  useLlamaParse,
  observability,
-  useCase,
 }: RunCreateLlamaOptions): Promise<CreateLlamaResult> {
  if (!process.env.OPENAI_API_KEY || !process.env.LLAMA_CLOUD_API_KEY) {
    throw new Error(
@@ -88,15 +88,21 @@ export async function runCreateLlama({
    ...dataSourceArgs,
    "--vector-db",
    vectorDb,
-    "--use-npm",
+    "--open-ai-key",
+    process.env.OPENAI_API_KEY,
+    "--use-pnpm",
    "--port",
    port,
+    "--external-port",
+    externalPort,
    "--post-install-action",
    postInstallAction,
    "--tools",
    tools ?? "none",
    "--observability",
    "none",
+    "--llama-cloud-key",
+    process.env.LLAMA_CLOUD_API_KEY,
  ];

  if (templateUI) {
@@ -113,14 +119,6 @@ export async function runCreateLlama({
  if (observability) {
    commandArgs.push("--observability", observability);
  }
-  if (
-    (templateType === "multiagent" ||
-      templateType === "reflex" ||
-      templateType === "llamaindexserver") &&
-    useCase
-  ) {
-    commandArgs.push("--use-case", useCase);
-  }

  const command = commandArgs.join(" ");
  console.log(`running command '${command}' in ${cwd}`);
@@ -143,7 +141,12 @@ export async function runCreateLlama({

  // Wait for app to start
  if (postInstallAction === "runApp") {
-    await waitPorts([port]);
+    await checkAppHasStarted(
+      appType === "--frontend",
+      templateFramework,
+      port,
+      externalPort,
+    );
  } else if (postInstallAction === "dependencies") {
    await waitForProcess(appProcess, 1000 * 60); // wait 1 min for dependencies to be resolved
  } else {
@@ -163,6 +166,19 @@ export async function createTestDir() {
  return cwd;
 }

+// eslint-disable-next-line max-params
+async function checkAppHasStarted(
+  frontend: boolean,
+  framework: TemplateFramework,
+  port: number,
+  externalPort: number,
+) {
+  const portsToWait = frontend
+    ? [port, externalPort]
+    : [framework === "nextjs" ? port : externalPort];
+  await waitPorts(portsToWait);
+}
+
 async function waitPorts(ports: number[]): Promise<void> {
  const waitForPort = async (port: number): Promise<void> => {
    await waitPort({
@@ -61,9 +61,6 @@ export const assetRelocator = (name: string) => {
    case "README-template.md": {
      return "README.md";
    }
-    case "vscode_settings.json": {
-      return "settings.json";
-    }
    default: {
      return name;
    }
@@ -11,47 +11,6 @@ export const EXAMPLE_FILE: TemplateDataSource = {
  },
 };

-export const EXAMPLE_10K_SEC_FILES: TemplateDataSource[] = [
-  {
-    type: "file",
-    config: {
-      url: new URL(
-        "https://s2.q4cdn.com/470004039/files/doc_earnings/2023/q4/filing/_10-K-Q4-2023-As-Filed.pdf",
-      ),
-      filename: "apple_10k_report.pdf",
-    },
-  },
-  {
-    type: "file",
-    config: {
-      url: new URL(
-        "https://ir.tesla.com/_flysystem/s3/sec/000162828024002390/tsla-20231231-gen.pdf",
-      ),
-      filename: "tesla_10k_report.pdf",
-    },
-  },
-];
-
-export const EXAMPLE_GDPR: TemplateDataSource = {
-  type: "file",
-  config: {
-    url: new URL(
-      "https://eur-lex.europa.eu/legal-content/EN/TXT/PDF/?uri=CELEX:32016R0679",
-    ),
-    filename: "gdpr.pdf",
-  },
-};
-
-export const AI_REPORTS: TemplateDataSource = {
-  type: "file",
-  config: {
-    url: new URL(
-      "https://www.europarl.europa.eu/RegData/etudes/ATAG/2024/760392/EPRS_ATA(2024)760392_EN.pdf",
-    ),
-    filename: "EPRS_ATA_2024_760392_EN.pdf",
-  },
-};
-
 export function getDataSources(
  files?: string,
  exampleFile?: boolean,
@@ -1,26 +1,40 @@
 import fs from "fs";
 import path from "path";
-import { assetRelocator, copy } from "./copy";
 import { TemplateFramework } from "./types";

 function renderDevcontainerContent(
  templatesDir: string,
  framework: TemplateFramework,
+  frontend: boolean,
 ) {
  const devcontainerJson: any = JSON.parse(
    fs.readFileSync(path.join(templatesDir, "devcontainer.json"), "utf8"),
  );

  // Modify postCreateCommand
-  devcontainerJson.postCreateCommand =
-    framework === "fastapi" ? "poetry install" : "npm install";
+  if (frontend) {
+    devcontainerJson.postCreateCommand =
+      framework === "fastapi"
+        ? "cd backend && poetry install && cd ../frontend && npm install"
+        : "cd backend && npm install && cd ../frontend && npm install";
+  } else {
+    devcontainerJson.postCreateCommand =
+      framework === "fastapi" ? "poetry install" : "npm install";
+  }

  // Modify containerEnv
  if (framework === "fastapi") {
-    devcontainerJson.containerEnv = {
-      ...devcontainerJson.containerEnv,
-      PYTHONPATH: "${PYTHONPATH}:${workspaceFolder}",
-    };
+    if (frontend) {
+      devcontainerJson.containerEnv = {
+        ...devcontainerJson.containerEnv,
+        PYTHONPATH: "${PYTHONPATH}:${workspaceFolder}/backend",
+      };
+    } else {
+      devcontainerJson.containerEnv = {
+        ...devcontainerJson.containerEnv,
+        PYTHONPATH: "${PYTHONPATH}:${workspaceFolder}",
+      };
+    }
  }

  return JSON.stringify(devcontainerJson, null, 2);
@@ -30,6 +44,7 @@ export const writeDevcontainer = async (
  root: string,
  templatesDir: string,
  framework: TemplateFramework,
+  frontend: boolean,
 ) => {
  const devcontainerDir = path.join(root, ".devcontainer");
  if (fs.existsSync(devcontainerDir)) {
@@ -39,6 +54,7 @@ export const writeDevcontainer = async (
  const devcontainerContent = renderDevcontainerContent(
    templatesDir,
    framework,
+    frontend,
  );
  fs.mkdirSync(devcontainerDir);
  await fs.promises.writeFile(
@@ -46,25 +62,3 @@ export const writeDevcontainer = async (
    devcontainerContent,
  );
 };
-
-export const copyVSCodeSettings = async (
-  root: string,
-  templatesDir: string,
-) => {
-  const vscodeDir = path.join(root, ".vscode");
-  await copy("vscode_settings.json", vscodeDir, {
-    cwd: templatesDir,
-    rename: assetRelocator,
-  });
-};
-
-export const configVSCode = async (
-  root: string,
-  templatesDir: string,
-  framework: TemplateFramework,
-) => {
-  await writeDevcontainer(root, templatesDir, framework);
-  if (framework === "fastapi") {
-    await copyVSCodeSettings(root, templatesDir);
-  }
-};
@@ -13,12 +13,6 @@ import {

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

-const DEFAULT_SYSTEM_PROMPT =
-  "You are a helpful assistant who helps users with their questions.";
-
-const DATA_SOURCES_PROMPT =
-  "You have access to a knowledge base including the facts that you should start with to find the answer for the user question. Use the query engine tool to retrieve the facts from the knowledge base.";
-
 export type EnvVar = {
  name?: string;
  description?: string;
@@ -44,7 +38,6 @@ const renderEnvVar = (envVars: EnvVar[]): string => {
 const getVectorDBEnvs = (
  vectorDb?: TemplateVectorDB,
  framework?: TemplateFramework,
-  template?: TemplateType,
 ): EnvVar[] => {
  if (!vectorDb || !framework) {
    return [];
@@ -169,7 +162,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)
            [
              {
@@ -224,15 +217,7 @@ 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 [];
  }
 };

@@ -351,20 +336,6 @@ const getModelEnvs = (modelConfig: ModelConfig): EnvVar[] => {
          },
        ]
      : []),
-    ...(modelConfig.provider === "huggingface"
-      ? [
-          {
-            name: "EMBEDDING_BACKEND",
-            description:
-              "The backend to use for the Sentence Transformers embedding model, either 'torch', 'onnx', or 'openvino'. Defaults to 'onnx'.",
-          },
-          {
-            name: "EMBEDDING_TRUST_REMOTE_CODE",
-            description:
-              "Whether to trust remote code for the embedding model, required for some models with custom code.",
-          },
-        ]
-      : []),
    ...(modelConfig.provider === "t-systems"
      ? [
          {
@@ -385,48 +356,37 @@ 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") {
-    result.push({
-      name: "NEXT_PUBLIC_CHAT_API",
-      description:
-        "The API for the chat endpoint. Set when using a custom backend (e.g. Express). Use full URL like http://localhost:8000/api/chat",
-    });
-  }
  return result;
 };

@@ -462,6 +422,9 @@ const getSystemPromptEnv = (
  dataSources?: TemplateDataSource[],
  template?: TemplateType,
 ): EnvVar[] => {
+  const defaultSystemPrompt =
+    "You are a helpful assistant who helps users with their questions.";
+
  const systemPromptEnv: EnvVar[] = [];
  // build tool system prompt by merging all tool system prompts
  // multiagent template doesn't need system prompt
@@ -476,12 +439,9 @@ const getSystemPromptEnv = (
      }
    });

-    const systemPrompt =
-      '"' +
-      DEFAULT_SYSTEM_PROMPT +
-      (dataSources?.length ? `\n${DATA_SOURCES_PROMPT}` : "") +
-      (toolSystemPrompt ? `\n${toolSystemPrompt}` : "") +
-      '"';
+    const systemPrompt = toolSystemPrompt
+      ? `\"${toolSystemPrompt}\"`
+      : defaultSystemPrompt;

    systemPromptEnv.push({
      name: "SYSTEM_PROMPT",
@@ -532,7 +492,7 @@ Here is the conversation history
 ---------------------
 {conversation}
 ---------------------
-Given the conversation history, please give me 3 questions that user might ask next!
+Given the conversation history, please give me 3 questions that you might ask next!
 Your answer should be wrapped in three sticks which follows the following format:
 \`\`\`
 <question 1>
@@ -573,44 +533,28 @@ export const createBackendEnvFile = async (
    | "framework"
    | "dataSources"
    | "template"
-    | "port"
+    | "externalPort"
    | "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.externalPort),
+    ...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);
@@ -621,10 +565,18 @@ export const createBackendEnvFile = async (
 export const createFrontendEnvFile = async (
  root: string,
  opts: {
+    customApiPath?: string;
    vectorDb?: TemplateVectorDB;
  },
 ) => {
  const defaultFrontendEnvs = [
+    {
+      name: "NEXT_PUBLIC_CHAT_API",
+      description: "The backend API for chat endpoint.",
+      value: opts.customApiPath
+        ? opts.customApiPath
+        : "http://localhost:8000/api/chat",
+    },
    {
      name: "NEXT_PUBLIC_USE_LLAMACLOUD",
      description: "Let's the user change indexes in LlamaCloud projects",
@@ -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";
@@ -21,7 +22,6 @@ import {
  TemplateVectorDB,
 } from "./types";
 import { installTSTemplate } from "./typescript";
-import { isHavingUvLockFile, tryUvRun } from "./uv";

 const checkForGenerateScript = (
  modelConfig: ModelConfig,
@@ -41,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");
  }

@@ -64,7 +60,7 @@ async function generateContextData(
  if (packageManager) {
    const runGenerate = `${cyan(
      framework === "fastapi"
-        ? "uv run generate"
+        ? "poetry run generate"
        : `${packageManager} run generate`,
    )}`;

@@ -78,21 +74,15 @@ 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.`);
@@ -102,16 +92,10 @@ async function generateContextData(
    }

    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));
-};
-
 const prepareContextData = async (
  root: string,
  dataSources: TemplateDataSource[],
@@ -119,29 +103,12 @@ const prepareContextData = async (
  await makeDir(path.join(root, "data"));
  for (const dataSource of dataSources) {
    const dataSourceConfig = dataSource?.config as FileSourceConfig;
-    // If the path is URLs, download the data and save it to the data directory
-    if ("url" in dataSourceConfig) {
-      console.log(
-        "Downloading file from URL:",
-        dataSourceConfig.url.toString(),
-      );
-      const destPath = path.join(
-        root,
-        "data",
-        dataSourceConfig.filename ??
-          path.basename(dataSourceConfig.url.toString()),
-      );
-      await downloadFile(dataSourceConfig.url.toString(), destPath);
-    } else {
-      // Copy local data
-      console.log("Copying data from path:", dataSourceConfig.path);
-      const destPath = path.join(
-        root,
-        "data",
-        path.basename(dataSourceConfig.path),
-      );
-      await fsExtra.copy(dataSourceConfig.path, destPath);
-    }
+    // Copy local data
+    const dataPath = dataSourceConfig.path;
+
+    const destPath = path.join(root, "data", path.basename(dataPath));
+    console.log("Copying data from path:", dataPath);
+    await fsExtra.copy(dataPath, destPath);
  }
 };

@@ -176,17 +143,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
@@ -196,13 +152,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 === "extractor"
+    ) {
      await createBackendEnvFile(props.root, props);
    }

@@ -234,6 +203,7 @@ export const installTemplate = async (
  } else {
    // this is a frontend for a full-stack app, create .env file with model information
    await createFrontendEnvFile(props.root, {
+      customApiPath: props.customApiPath,
      vectorDb: props.vectorDb,
    });
  }
@@ -143,6 +143,6 @@ export const installLlamapackProject = async ({
  await copyData({ root });
  await installLlamapackExample({ root, llamapack });
  if (postInstallAction === "runApp" || postInstallAction === "dependencies") {
-    installPythonDependencies();
+    installPythonDependencies({ noRoot: true });
  }
 };
@@ -1,3 +1,4 @@
+import ciInfo from "ci-info";
 import prompts from "prompts";
 import { ModelConfigParams } from ".";
 import { questionHandlers, toChoice } from "../../questions/utils";
@@ -69,7 +70,9 @@ export async function askAnthropicQuestions({
    config.apiKey = key || process.env.ANTHROPIC_API_KEY;
  }

-  if (askModels) {
+  // use default model values in CI or if user should not be asked
+  const useDefaults = ciInfo.isCI || !askModels;
+  if (!useDefaults) {
    const { model } = await prompts(
      {
        type: "select",
@@ -1,3 +1,4 @@
+import ciInfo from "ci-info";
 import prompts from "prompts";
 import { ModelConfigParams, ModelConfigQuestionsParams } from ".";
 import { questionHandlers } from "../../questions/utils";
@@ -66,7 +67,9 @@ export async function askAzureQuestions({
    },
  };

-  if (askModels) {
+  // use default model values in CI or if user should not be asked
+  const useDefaults = ciInfo.isCI || !askModels;
+  if (!useDefaults) {
    const { model } = await prompts(
      {
        type: "select",
@@ -1,3 +1,4 @@
+import ciInfo from "ci-info";
 import prompts from "prompts";
 import { ModelConfigParams } from ".";
 import { questionHandlers, toChoice } from "../../questions/utils";
@@ -53,7 +54,9 @@ export async function askGeminiQuestions({
    config.apiKey = key || process.env.GOOGLE_API_KEY;
  }

-  if (askModels) {
+  // use default model values in CI or if user should not be asked
+  const useDefaults = ciInfo.isCI || !askModels;
+  if (!useDefaults) {
    const { model } = await prompts(
      {
        type: "select",
@@ -1,3 +1,4 @@
+import ciInfo from "ci-info";
 import prompts from "prompts";
 import { ModelConfigParams } from ".";
 import { questionHandlers, toChoice } from "../../questions/utils";
@@ -109,7 +110,9 @@ export async function askGroqQuestions({
    config.apiKey = key || process.env.GROQ_API_KEY;
  }

-  if (askModels) {
+  // use default model values in CI or if user should not be asked
+  const useDefaults = ciInfo.isCI || !askModels;
+  if (!useDefaults) {
    const modelChoices = await getAvailableModelChoicesGroq(config.apiKey!);

    const { model } = await prompts(
@@ -5,7 +5,6 @@ import { askAnthropicQuestions } from "./anthropic";
 import { askAzureQuestions } from "./azure";
 import { askGeminiQuestions } from "./gemini";
 import { askGroqQuestions } from "./groq";
-import { askHuggingfaceQuestions } from "./huggingface";
 import { askLLMHubQuestions } from "./llmhub";
 import { askMistralQuestions } from "./mistral";
 import { askOllamaQuestions } from "./ollama";
@@ -40,7 +39,6 @@ export async function askModelConfig({

    if (framework === "fastapi") {
      choices.push({ title: "T-Systems", value: "t-systems" });
-      choices.push({ title: "Huggingface", value: "huggingface" });
    }
    const { provider } = await prompts(
      {
@@ -78,9 +76,6 @@ export async function askModelConfig({
    case "t-systems":
      modelConfig = await askLLMHubQuestions({ askModels });
      break;
-    case "huggingface":
-      modelConfig = await askHuggingfaceQuestions({ askModels });
-      break;
    default:
      modelConfig = await askOpenAIQuestions({
        openAiKey,
@@ -1,3 +1,4 @@
+import ciInfo from "ci-info";
 import got from "got";
 import ora from "ora";
 import { red } from "picocolors";
@@ -79,7 +80,9 @@ export async function askLLMHubQuestions({
    config.apiKey = key || process.env.T_SYSTEMS_LLMHUB_API_KEY;
  }

-  if (askModels) {
+  // use default model values in CI or if user should not be asked
+  const useDefaults = ciInfo.isCI || !askModels;
+  if (!useDefaults) {
    const { model } = await prompts(
      {
        type: "select",
@@ -1,3 +1,4 @@
+import ciInfo from "ci-info";
 import prompts from "prompts";
 import { ModelConfigParams } from ".";
 import { questionHandlers, toChoice } from "../../questions/utils";
@@ -52,7 +53,9 @@ export async function askMistralQuestions({
    config.apiKey = key || process.env.MISTRAL_API_KEY;
  }

-  if (askModels) {
+  // use default model values in CI or if user should not be asked
+  const useDefaults = ciInfo.isCI || !askModels;
+  if (!useDefaults) {
    const { model } = await prompts(
      {
        type: "select",
@@ -1,3 +1,4 @@
+import ciInfo from "ci-info";
 import ollama, { type ModelResponse } from "ollama";
 import { red } from "picocolors";
 import prompts from "prompts";
@@ -33,7 +34,9 @@ export async function askOllamaQuestions({
    },
  };

-  if (askModels) {
+  // use default model values in CI or if user should not be asked
+  const useDefaults = ciInfo.isCI || !askModels;
+  if (!useDefaults) {
    const { model } = await prompts(
      {
        type: "select",
@@ -1,9 +1,9 @@
+import ciInfo from "ci-info";
 import got from "got";
 import ora from "ora";
 import { red } from "picocolors";
 import prompts from "prompts";
 import { ModelConfigParams, ModelConfigQuestionsParams } from ".";
-import { isCI } from "../../questions";
 import { questionHandlers } from "../../questions/utils";

 const OPENAI_API_URL = "https://api.openai.com/v1";
@@ -31,7 +31,7 @@ export async function askOpenAIQuestions({
    },
  };

-  if (!config.apiKey && !isCI) {
+  if (!config.apiKey) {
    const { key } = await prompts(
      {
        type: "text",
@@ -54,7 +54,9 @@ export async function askOpenAIQuestions({
    config.apiKey = key || process.env.OPENAI_API_KEY;
  }

-  if (askModels) {
+  // use default model values in CI or if user should not be asked
+  const useDefaults = ciInfo.isCI || !askModels;
+  if (!useDefaults) {
    const { model } = await prompts(
      {
        type: "select",
@@ -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";
@@ -21,7 +20,6 @@ interface Dependency {
  name: string;
  version?: string;
  extras?: string[];
-  constraints?: Record<string, string>;
 }

 const getAdditionalDependencies = (
@@ -30,7 +28,6 @@ const getAdditionalDependencies = (
  dataSources?: TemplateDataSource[],
  tools?: Tool[],
  templateType?: TemplateType,
-  observability?: TemplateObservability,
 ) => {
  const dependencies: Dependency[] = [];

@@ -39,73 +36,67 @@ const getAdditionalDependencies = (
    case "mongo": {
      dependencies.push({
        name: "llama-index-vector-stores-mongodb",
-        version: ">=0.3.2,<0.4.0",
+        version: "^0.3.1",
      });
      break;
    }
    case "pg": {
      dependencies.push({
        name: "llama-index-vector-stores-postgres",
-        version: ">=0.3.2,<0.4.0",
+        version: "^0.2.5",
      });
      break;
    }
    case "pinecone": {
      dependencies.push({
        name: "llama-index-vector-stores-pinecone",
-        version: ">=0.4.1,<0.5.0",
-        constraints: {
-          python: ">=3.11,<3.13",
-        },
+        version: "^0.2.1",
      });
      break;
    }
    case "milvus": {
      dependencies.push({
        name: "llama-index-vector-stores-milvus",
-        version: ">=0.3.0,<0.4.0",
+        version: "^0.2.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.2.0",
      });
      break;
    }
    case "qdrant": {
      dependencies.push({
        name: "llama-index-vector-stores-qdrant",
-        version: ">=0.4.0,<0.5.0",
-        constraints: {
-          python: ">=3.11,<3.13",
-        },
+        version: "^0.3.0",
      });
      break;
    }
    case "chroma": {
      dependencies.push({
        name: "llama-index-vector-stores-chroma",
-        version: ">=0.4.0,<0.5.0",
+        version: "^0.2.0",
      });
      break;
    }
    case "weaviate": {
      dependencies.push({
        name: "llama-index-vector-stores-weaviate",
-        version: ">=1.2.3,<2.0.0",
+        version: "^1.1.1",
      });
      break;
    }
    case "llamacloud":
      dependencies.push({
        name: "llama-index-indices-managed-llama-cloud",
-        version: ">=0.6.3,<0.7.0",
+        version: "^0.3.1",
      });
      break;
  }
@@ -118,28 +109,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.2.2",
          });
          break;
        case "db":
          dependencies.push({
            name: "llama-index-readers-database",
-            version: ">=0.3.0,<0.4.0",
+            version: "^0.2.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;
      }
@@ -158,122 +149,135 @@ 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.2.0",
        });
        dependencies.push({
          name: "llama-index-embeddings-openai",
-          version: ">=0.3.1,<0.4.0",
+          version: "^0.2.3",
        });
        dependencies.push({
          name: "llama-index-agent-openai",
-          version: ">=0.4.0,<0.5.0",
+          version: "^0.3.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",
-      });
-      break;
-    case "huggingface":
-      dependencies.push({
-        name: "llama-index-llms-huggingface",
-        version: ">=0.5.0,<0.6.0",
-      });
-      dependencies.push({
-        name: "llama-index-embeddings-huggingface",
-        version: ">=0.5.0,<0.6.0",
-      });
-      dependencies.push({
-        name: "optimum",
-        version: ">=1.23.3,<2.0.0",
-        extras: ["onnxruntime"],
+        version: "0.2.4",
      });
      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,<0.16.0",
-      });
+  return dependencies;
+};
+
+const mergePoetryDependencies = (
+  dependencies: Dependency[],
+  existingDependencies: Record<string, Omit<Dependency, "name"> | string>,
+) => {
+  for (const dependency of dependencies) {
+    let value = existingDependencies[dependency.name] ?? {};
+
+    // default string value is equal to attribute "version"
+    if (typeof value === "string") {
+      value = { version: value };
    }
-    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;
+
+    if (value.version === undefined) {
+      throw new Error(
+        `Dependency "${dependency.name}" is missing attribute "version"!`,
+      );
+    }
+
+    // Serialize separately only if extras are provided
+    if (value.extras && value.extras.length > 0) {
+      existingDependencies[dependency.name] = value;
+    } else {
+      // Otherwise, serialize just the version string
+      existingDependencies[dependency.name] = value.version;
    }
  }
-
-  return dependencies;
 };

 const copyRouterCode = async (root: string, tools: Tool[]) => {
@@ -298,100 +302,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`,
@@ -400,16 +323,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);
@@ -417,34 +342,51 @@ export const installPythonDependencies = () => {
  } else {
    console.error(
      red(
-        `uv is not available in the current environment. Please check ${terminalLink(
-          "uv Installation",
-          `https://github.com/astral-sh/uv#installation`,
-        )} to install uv first, then run create-llama again.`,
+        `Poetry is not available in the current environment. Please check ${terminalLink(
+          "Poetry Installation",
+          `https://python-poetry.org/docs/#installation`,
+        )} to install poetry first, then run create-llama again.`,
      ),
    );
    process.exit(1);
  }
 };

-const installLegacyPythonTemplate = async ({
+export const installPythonTemplate = async ({
  root,
  template,
+  framework,
  vectorDb,
  dataSources,
  tools,
-  useCase,
+  postInstallAction,
  observability,
+  modelConfig,
 }: Pick<
  InstallTemplateArgs,
  | "root"
+  | "framework"
  | "template"
  | "vectorDb"
  | "dataSources"
  | "tools"
-  | "useCase"
+  | "postInstallAction"
  | "observability"
+  | "modelConfig"
 >) => {
+  console.log("\nInitializing Python project with template:", template, "\n");
+  let templatePath;
+  if (template === "extractor") {
+    templatePath = path.join(templatesDir, "types", "extractor", framework);
+  } else {
+    templatePath = path.join(templatesDir, "types", "streaming", framework);
+  }
+  await copy("**", root, {
+    parents: true,
+    cwd: templatePath,
+    rename: assetRelocator,
+  });
+
  const compPath = path.join(templatesDir, "components");
  const enginePath = path.join(root, "app", "engine");

@@ -505,36 +447,40 @@ const installLegacyPythonTemplate = async ({
    await copyRouterCode(root, tools ?? []);
  }

-  // Copy multiagents overrides
  if (template === "multiagent") {
+    // Copy multi-agent code
    await copy("**", path.join(root), {
+      parents: true,
      cwd: path.join(compPath, "multiagent", "python"),
+      rename: assetRelocator,
    });
  }

-  if (template === "multiagent" || template === "reflex") {
-    if (useCase) {
-      const sourcePath =
-        template === "multiagent"
-          ? path.join(compPath, "agents", "python", useCase)
-          : path.join(compPath, "reflex", useCase);
+  console.log("Adding additional dependencies");

-      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);
-    }
-  }
+  const addOnDependencies = getAdditionalDependencies(
+    modelConfig,
+    vectorDb,
+    dataSources,
+    tools,
+    template,
+  );

  if (observability && observability !== "none") {
+    if (observability === "traceloop") {
+      addOnDependencies.push({
+        name: "traceloop-sdk",
+        version: "^0.15.11",
+      });
+    }
+
+    if (observability === "llamatrace") {
+      addOnDependencies.push({
+        name: "llama-index-callbacks-arize-phoenix",
+        version: "^0.2.1",
+      });
+    }
+
    const templateObservabilityPath = path.join(
      templatesDir,
      "components",
@@ -546,137 +492,15 @@ const installLegacyPythonTemplate = async ({
      cwd: templateObservabilityPath,
    });
  }
-};
-
-const installLlamaIndexServerTemplate = async ({
-  root,
-  useCase,
-  useLlamaParse,
-}: Pick<InstallTemplateArgs, "root" | "useCase" | "useLlamaParse">) => {
-  if (!useCase) {
-    console.log(
-      red(
-        `There is no use case selected. Please pick a use case to use via --use-case flag.`,
-      ),
-    );
-    process.exit(1);
-  }
-
-  await copy("workflow.py", path.join(root, "app"), {
-    parents: true,
-    cwd: path.join(templatesDir, "components", "workflows", "python", useCase),
-  });
-
-  // Copy custom UI component code
-  await copy(`*`, path.join(root, "components"), {
-    parents: true,
-    cwd: path.join(templatesDir, "components", "ui", "workflows", useCase),
-  });
-
-  if (useLlamaParse) {
-    await copy("index.py", path.join(root, "app"), {
-      parents: true,
-      cwd: path.join(
-        templatesDir,
-        "components",
-        "vectordbs",
-        "llamaindexserver",
-        "llamacloud",
-        "python",
-      ),
-    });
-    // TODO: Consider moving generate.py to app folder.
-    await copy("generate.py", path.join(root), {
-      parents: true,
-      cwd: path.join(
-        templatesDir,
-        "components",
-        "vectordbs",
-        "llamaindexserver",
-        "llamacloud",
-        "python",
-      ),
-    });
-  }
-  // Copy README.md
-  await copy("README-template.md", path.join(root), {
-    parents: true,
-    cwd: path.join(templatesDir, "components", "workflows", "python", useCase),
-    rename: assetRelocator,
-  });
-};
-
-export const installPythonTemplate = async ({
-  appName,
-  root,
-  template,
-  framework,
-  vectorDb,
-  postInstallAction,
-  modelConfig,
-  dataSources,
-  tools,
-  useLlamaParse,
-  useCase,
-  observability,
-}: Pick<
-  InstallTemplateArgs,
-  | "appName"
-  | "root"
-  | "template"
-  | "framework"
-  | "vectorDb"
-  | "postInstallAction"
-  | "modelConfig"
-  | "dataSources"
-  | "tools"
-  | "useLlamaParse"
-  | "useCase"
-  | "observability"
->) => {
-  console.log("\nInitializing Python project with template:", template, "\n");
-  let templatePath;
-  if (template === "reflex") {
-    templatePath = path.join(templatesDir, "types", "reflex");
-  } else {
-    templatePath = path.join(templatesDir, "types", template, framework);
-  }
-  await copy("**", root, {
-    parents: true,
-    cwd: templatePath,
-    rename: assetRelocator,
-  });
-
-  if (template === "llamaindexserver") {
-    await installLlamaIndexServerTemplate({
-      root,
-      useCase,
-      useLlamaParse,
-    });
-  } else {
-    await installLegacyPythonTemplate({
-      root,
-      template,
-      vectorDb,
-      dataSources,
-      tools,
-      useCase,
-      observability,
-    });
-  }
-
-  console.log("Adding additional dependencies");
-  const addOnDependencies = getAdditionalDependencies(
-    modelConfig,
-    vectorDb,
-    dataSources,
-    tools,
-    template,
-  );

  await addDependencies(root, addOnDependencies);

  if (postInstallAction === "runApp" || postInstallAction === "dependencies") {
    installPythonDependencies();
  }
+
+  // Copy deployment files for python
+  await copy("**", root, {
+    cwd: path.join(compPath, "deployments", "python"),
+  });
 };
@@ -0,0 +1,99 @@
+import { ChildProcess, SpawnOptions, spawn } from "child_process";
+import path from "path";
+import { TemplateFramework } from "./types";
+
+const createProcess = (
+  command: string,
+  args: string[],
+  options: SpawnOptions,
+) => {
+  return spawn(command, args, {
+    ...options,
+    shell: true,
+  })
+    .on("exit", function (code) {
+      if (code !== 0) {
+        console.log(`Child process exited with code=${code}`);
+        process.exit(1);
+      }
+    })
+    .on("error", function (err) {
+      console.log("Error when running chill process: ", err);
+      process.exit(1);
+    });
+};
+
+export function runReflexApp(
+  appPath: string,
+  frontendPort?: number,
+  backendPort?: number,
+) {
+  const commandArgs = ["run", "reflex", "run"];
+  if (frontendPort) {
+    commandArgs.push("--frontend-port", frontendPort.toString());
+  }
+  if (backendPort) {
+    commandArgs.push("--backend-port", backendPort.toString());
+  }
+  return createProcess("poetry", commandArgs, {
+    stdio: "inherit",
+    cwd: appPath,
+  });
+}
+
+export function runFastAPIApp(appPath: string, port: number) {
+  const commandArgs = ["run", "uvicorn", "main:app", "--port=" + port];
+
+  return createProcess("poetry", commandArgs, {
+    stdio: "inherit",
+    cwd: appPath,
+  });
+}
+
+export function runTSApp(appPath: string, port: number) {
+  return createProcess("npm", ["run", "dev"], {
+    stdio: "inherit",
+    cwd: appPath,
+    env: { ...process.env, PORT: `${port}` },
+  });
+}
+
+export async function runApp(
+  appPath: string,
+  template: string,
+  frontend: boolean,
+  framework: TemplateFramework,
+  port?: number,
+  externalPort?: number,
+): Promise<any> {
+  const processes: ChildProcess[] = [];
+
+  // Callback to kill all sub processes if the main process is killed
+  process.on("exit", () => {
+    console.log("Killing app processes...");
+    processes.forEach((p) => p.kill());
+  });
+
+  // Default sub app paths
+  const backendPath = path.join(appPath, "backend");
+  const frontendPath = path.join(appPath, "frontend");
+
+  if (template === "extractor") {
+    processes.push(runReflexApp(appPath, port, externalPort));
+  }
+  if (template === "streaming" || template === "multiagent") {
+    if (framework === "fastapi" || framework === "express") {
+      const backendRunner = framework === "fastapi" ? runFastAPIApp : runTSApp;
+      if (frontend) {
+        processes.push(backendRunner(backendPath, externalPort || 8000));
+        processes.push(runTSApp(frontendPath, port || 3000));
+      } else {
+        processes.push(backendRunner(appPath, externalPort || 8000));
+      }
+    } else if (framework === "nextjs") {
+      processes.push(runTSApp(appPath, port || 3000));
+    }
+  }
+
+  return Promise.all(processes);
+}
@@ -41,7 +41,7 @@ export const supportedTools: Tool[] = [
    dependencies: [
      {
        name: "llama-index-tools-google",
-        version: ">=0.3.0,<0.4.0",
+        version: "^0.2.0",
      },
    ],
    supportedFrameworks: ["fastapi"],
@@ -62,16 +62,17 @@ export const supportedTools: Tool[] = [
    dependencies: [
      {
        name: "duckduckgo-search",
-        version: ">=6.3.5,<7.0.0",
+        version: "6.1.7",
      },
    ],
-    supportedFrameworks: ["fastapi"], // TODO: Re-enable this tool once the duck-duck-scrape TypeScript library works again
+    supportedFrameworks: ["fastapi", "nextjs", "express"],
    type: ToolType.LOCAL,
    envVars: [
      {
        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
        description: "System prompt for DuckDuckGo search tool.",
-        value: `You have access to the duckduckgo search tool. Use it to get information from the web to answer user questions.
+        value: `You are a DuckDuckGo search agent. 
+You can use the duckduckgo search tool to get information from the web to answer user questions.
 For better results, you can specify the region parameter to get results from a specific region but it's optional.`,
      },
    ],
@@ -82,11 +83,18 @@ 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.2.0",
      },
    ],
    supportedFrameworks: ["fastapi", "express", "nextjs"],
    type: ToolType.LLAMAHUB,
+    envVars: [
+      {
+        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
+        description: "System prompt for wiki tool.",
+        value: `You are a Wikipedia agent. You help users to get information from Wikipedia.`,
+      },
+    ],
  },
  {
    display: "Weather",
@@ -94,6 +102,13 @@ For better results, you can specify the region parameter to get results from a s
    dependencies: [],
    supportedFrameworks: ["fastapi", "express", "nextjs"],
    type: ToolType.LOCAL,
+    envVars: [
+      {
+        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
+        description: "System prompt for weather tool.",
+        value: `You are a weather forecast agent. You help users to get the weather forecast for a given location.`,
+      },
+    ],
  },
  {
    display: "Document generator",
@@ -102,11 +117,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 +139,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: "0.0.10",
      },
    ],
    supportedFrameworks: ["fastapi", "express", "nextjs"],
@@ -155,7 +170,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: "^0.0.11b38",
      },
    ],
    supportedFrameworks: ["fastapi", "express", "nextjs"],
@@ -184,7 +199,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",
@@ -196,6 +211,14 @@ For better results, you can specify the region parameter to get results from a s
    },
    supportedFrameworks: ["fastapi", "express", "nextjs"],
    type: ToolType.LOCAL,
+    envVars: [
+      {
+        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
+        description: "System prompt for openapi action tool.",
+        value:
+          "You are an OpenAPI action agent. You help users to make requests to the provided OpenAPI schema.",
+      },
+    ],
  },
  {
    display: "Image Generator",
@@ -208,6 +231,11 @@ For better results, you can specify the region parameter to get results from a s
        description:
          "STABILITY_API_KEY key is required to run image generator. Get it here: https://platform.stability.ai/account/keys",
      },
+      {
+        name: TOOL_SYSTEM_PROMPT_ENV_VAR,
+        description: "System prompt for image generator tool.",
+        value: `You are an image generator agent. You help users to generate images using the Stability API.`,
+      },
    ],
  },
  {
@@ -239,22 +267,6 @@ For better results, you can specify the region parameter to get results from a s
      },
    ],
  },
-  {
-    display: "Form Filling",
-    name: "form_filling",
-    supportedFrameworks: ["fastapi"],
-    type: ToolType.LOCAL,
-    dependencies: [
-      {
-        name: "pandas",
-        version: ">=2.2.3,<3.0.0",
-      },
-      {
-        name: "tabulate",
-        version: ">=0.9.0,<1.0.0",
-      },
-    ],
-  },
 ];

 export const getTool = (toolName: string): Tool | undefined => {
@@ -325,16 +337,9 @@ export const writeToolsConfig = async (
      yaml.stringify(configContent),
    );
  } else {
-    // For Typescript, we treat llamahub tools as local tools
-    const tsConfigContent = {
-      local: {
-        ...configContent.local,
-        ...configContent.llamahub,
-      },
-    };
    await fs.writeFile(
      path.join(configPath, "tools.json"),
-      JSON.stringify(tsConfigContent, null, 2),
+      JSON.stringify(configContent, null, 2),
    );
  }
 };
@@ -9,7 +9,6 @@ export type ModelProvider =
  | "gemini"
  | "mistral"
  | "azure-openai"
-  | "huggingface"
  | "t-systems";
 export type ModelConfig = {
  provider: ModelProvider;
@@ -20,12 +19,11 @@ export type ModelConfig = {
  isConfigured(): boolean;
 };
 export type TemplateType =
+  | "extractor"
  | "streaming"
  | "community"
  | "llamapack"
-  | "multiagent"
-  | "reflex"
-  | "llamaindexserver";
+  | "multiagent";
 export type TemplateFramework = "nextjs" | "express" | "fastapi";
 export type TemplateUI = "html" | "shadcn";
 export type TemplateVectorDB =
@@ -50,24 +48,10 @@ export type TemplateDataSource = {
 };
 export type TemplateDataSourceType = "file" | "web" | "db";
 export type TemplateObservability = "none" | "traceloop" | "llamatrace";
-export type TemplateUseCase =
-  | "financial_report"
-  | "blog"
-  | "deep_research"
-  | "form_filling"
-  | "extractor"
-  | "contract_review"
-  | "agentic_rag";
 // Config for both file and folder
-export type FileSourceConfig =
-  | {
-      path: string;
-      filename?: string;
-    }
-  | {
-      url: URL;
-      filename?: string;
-    };
+export type FileSourceConfig = {
+  path: string;
+};
 export type WebSourceConfig = {
  baseUrl?: string;
  prefix?: string;
@@ -99,15 +83,15 @@ export interface InstallTemplateArgs {
  framework: TemplateFramework;
  ui: TemplateUI;
  dataSources: TemplateDataSource[];
+  customApiPath?: string;
  modelConfig: ModelConfig;
  llamaCloudKey?: string;
  useLlamaParse?: boolean;
  communityProjectConfig?: CommunityProjectConfig;
  llamapack?: string;
  vectorDb?: TemplateVectorDB;
-  port?: number;
+  externalPort?: number;
  postInstallAction?: TemplatePostInstallAction;
  tools?: Tool[];
  observability?: TemplateObservability;
-  useCase?: TemplateUseCase;
 }
@@ -1,111 +1,47 @@
 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";
+import { InstallTemplateArgs } from "./types";

-const installLlamaIndexServerTemplate = async ({
-  root,
-  useCase,
-  vectorDb,
-}: Pick<InstallTemplateArgs, "root" | "useCase" | "vectorDb">) => {
-  if (!useCase) {
-    console.log(
-      red(
-        `There is no use case selected. Please pick a use case to use via --use-case flag.`,
-      ),
-    );
-    process.exit(1);
-  }
-
-  if (!vectorDb) {
-    console.log(
-      red(
-        `There is no vector db selected. Please pick a vector db to use via --vector-db flag.`,
-      ),
-    );
-    process.exit(1);
-  }
-
-  await copy("workflow.ts", path.join(root, "src", "app"), {
-    parents: true,
-    cwd: path.join(
-      templatesDir,
-      "components",
-      "workflows",
-      "typescript",
-      useCase,
-    ),
-  });
-
-  // copy workflow UI components to output/components folder
-  await copy("*", path.join(root, "components"), {
-    parents: true,
-    cwd: path.join(templatesDir, "components", "ui", "workflows", useCase),
-  });
-
-  if (vectorDb === "llamacloud") {
-    await copy("generate.ts", path.join(root, "src"), {
-      parents: true,
-      cwd: path.join(
-        templatesDir,
-        "components",
-        "vectordbs",
-        "llamaindexserver",
-        "llamacloud",
-        "typescript",
-      ),
-    });
-
-    await copy("index.ts", path.join(root, "src", "app"), {
-      parents: true,
-      cwd: path.join(
-        templatesDir,
-        "components",
-        "vectordbs",
-        "llamaindexserver",
-        "llamacloud",
-        "typescript",
-      ),
-      rename: () => "data.ts",
-    });
-  }
-  // Copy README.md
-  await copy("README-template.md", path.join(root), {
-    parents: true,
-    cwd: path.join(
-      templatesDir,
-      "components",
-      "workflows",
-      "typescript",
-      useCase,
-    ),
-    rename: assetRelocator,
-  });
-};
-
-const installLegacyTSTemplate = async ({
+/**
+ * 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
   */
@@ -121,9 +57,11 @@ const installLegacyTSTemplate = async ({
      console.log("\nUsing static site generation\n");
    } else {
      if (vectorDb === "milvus") {
-        nextConfigJson.serverExternalPackages =
-          nextConfigJson.serverExternalPackages ?? [];
-        nextConfigJson.serverExternalPackages.push("@zilliz/milvus2-sdk-node");
+        nextConfigJson.experimental.serverComponentsExternalPackages =
+          nextConfigJson.experimental.serverComponentsExternalPackages ?? [];
+        nextConfigJson.experimental.serverComponentsExternalPackages.push(
+          "@zilliz/milvus2-sdk-node",
+        );
      }
    }
    await fs.writeFile(
@@ -160,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
@@ -190,34 +132,6 @@ const installLegacyTSTemplate = async ({
      cwd: path.join(multiagentPath, "workflow"),
    });

-    // Copy use case code for multiagent template
-    if (useCase) {
-      console.log("\nCopying use case:", useCase, "\n");
-      const useCasePath = path.join(compPath, "agents", "typescript", useCase);
-      const useCaseCodePath = path.join(useCasePath, "workflow");
-
-      // Copy use case codes
-      await copy("**", path.join(root, relativeEngineDestPath, "workflow"), {
-        parents: true,
-        cwd: useCaseCodePath,
-        rename: assetRelocator,
-      });
-
-      // Copy use case files to project root
-      await copy("*.*", path.join(root), {
-        parents: true,
-        cwd: useCasePath,
-        rename: assetRelocator,
-      });
-    } else {
-      console.log(
-        red(
-          `There is no use case selected for ${template} template. Please pick a use case to use via --use-case flag.`,
-        ),
-      );
-      process.exit(1);
-    }
-
    if (framework === "nextjs") {
      // patch route.ts file
      await copy("**", path.join(root, relativeEngineDestPath), {
@@ -240,12 +154,6 @@ const installLegacyTSTemplate = async ({
    cwd: path.join(compPath, "loaders", "typescript", loaderFolder),
  });

-  // copy provider settings
-  await copy("**", enginePath, {
-    parents: true,
-    cwd: path.join(compPath, "providers", "typescript", modelConfig.provider),
-  });
-
  // Select and copy engine code based on data sources and tools
  let engine;
  tools = tools ?? [];
@@ -294,75 +202,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,
@@ -373,79 +212,16 @@ export const installTSTemplate = async ({
    ui,
    observability,
    vectorDb,
-    backend,
-    modelConfig,
-    template,
  });

-  if (
-    backend &&
-    (postInstallAction === "runApp" || postInstallAction === "dependencies")
-  ) {
+  if (postInstallAction === "runApp" || postInstallAction === "dependencies") {
    await installTSDependencies(packageJson, packageManager, isOnline);
  }
-};

-const providerDependencies: {
-  [key in ModelProvider]?: Record<string, string>;
-} = {
-  openai: {
-    "@llamaindex/openai": "^0.2.0",
-  },
-  gemini: {
-    "@llamaindex/google": "^0.2.0",
-  },
-  ollama: {
-    "@llamaindex/ollama": "^0.1.0",
-  },
-  mistral: {
-    "@llamaindex/mistral": "^0.2.0",
-  },
-  "azure-openai": {
-    "@llamaindex/openai": "^0.2.0",
-  },
-  groq: {
-    "@llamaindex/groq": "^0.0.61",
-    "@llamaindex/huggingface": "^0.1.0", // groq uses huggingface as default embedding model
-  },
-  anthropic: {
-    "@llamaindex/anthropic": "^0.3.0",
-    "@llamaindex/huggingface": "^0.1.0", // anthropic uses huggingface as default embedding model
-  },
-};
-
-const vectorDbDependencies: Record<TemplateVectorDB, Record<string, string>> = {
-  astra: {
-    "@llamaindex/astra": "^0.0.5",
-  },
-  chroma: {
-    "@llamaindex/chroma": "^0.0.5",
-  },
-  llamacloud: {},
-  milvus: {
-    "@zilliz/milvus2-sdk-node": "^2.4.6",
-    "@llamaindex/milvus": "^0.1.0",
-  },
-  mongo: {
-    mongodb: "6.7.0",
-    "@llamaindex/mongodb": "^0.0.5",
-  },
-  none: {},
-  pg: {
-    pg: "^8.12.0",
-    pgvector: "^0.2.0",
-    "@llamaindex/postgres": "^0.0.33",
-  },
-  pinecone: {
-    "@llamaindex/pinecone": "^0.0.5",
-  },
-  qdrant: {
-    "@qdrant/js-client-rest": "^1.11.0",
-    "@llamaindex/qdrant": "^0.1.0",
-  },
-  weaviate: {
-    "@llamaindex/weaviate": "^0.0.5",
-  },
+  // Copy deployment files for typescript
+  await copy("**", root, {
+    cwd: path.join(compPath, "deployments", "typescript"),
+  });
 };

 async function updatePackageJson({
@@ -457,9 +233,6 @@ async function updatePackageJson({
  ui,
  observability,
  vectorDb,
-  backend,
-  modelConfig,
-  template,
 }: Pick<
  InstallTemplateArgs,
  | "root"
@@ -469,11 +242,8 @@ async function updatePackageJson({
  | "ui"
  | "observability"
  | "vectorDb"
-  | "modelConfig"
-  | "template"
 > & {
  relativeEngineDestPath: string;
-  backend: boolean;
 }): Promise<any> {
  const packageJsonFile = path.join(root, "package.json");
  const packageJson: any = JSON.parse(
@@ -482,7 +252,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 = {
@@ -509,29 +279,41 @@ async function updatePackageJson({
      "remark-gfm": undefined,
      "remark-math": undefined,
      "react-markdown": undefined,
-      "highlight.js": undefined,
+      "react-syntax-highlighter": undefined,
+    };
+
+    packageJson.devDependencies = {
+      ...packageJson.devDependencies,
+      "@types/react-syntax-highlighter": undefined,
    };
  }

-  if (backend) {
+  if (vectorDb === "pg") {
    packageJson.dependencies = {
      ...packageJson.dependencies,
-      "@llamaindex/readers": "^2.0.0",
+      pg: "^8.12.0",
+      pgvector: "^0.2.0",
    };
+  }

-    if (vectorDb && vectorDb in vectorDbDependencies) {
-      packageJson.dependencies = {
-        ...packageJson.dependencies,
-        ...vectorDbDependencies[vectorDb],
-      };
-    }
+  if (vectorDb === "qdrant") {
+    packageJson.dependencies = {
+      ...packageJson.dependencies,
+      "@qdrant/js-client-rest": "^1.11.0",
+    };
+  }
+  if (vectorDb === "mongo") {
+    packageJson.dependencies = {
+      ...packageJson.dependencies,
+      mongodb: "^6.7.0",
+    };
+  }

-    if (modelConfig.provider && modelConfig.provider in providerDependencies) {
-      packageJson.dependencies = {
-        ...packageJson.dependencies,
-        ...providerDependencies[modelConfig.provider],
-      };
-    }
+  if (vectorDb === "milvus") {
+    packageJson.dependencies = {
+      ...packageJson.dependencies,
+      "@zilliz/milvus2-sdk-node": "^2.4.6",
+    };
  }

  if (observability === "traceloop") {
@@ -134,6 +134,13 @@ const program = new Command(packageJson.name)
    `

  Select UI port.
+`,
+  )
+  .option(
+    "--external-port <external>",
+    `
+
+  Select external port.
 `,
  )
  .option(
@@ -201,13 +208,6 @@ const program = new Command(packageJson.name)
 `,
    false,
  )
-  .option(
-    "--use-case <useCase>",
-    `
-
-  Select which use case to use for the multi-agent template (e.g: financial_report, blog).
-`,
-  )
  .allowUnknownOption()
  .parse(process.argv);

@@ -215,7 +215,7 @@ const options = program.opts();

 if (
  process.argv.includes("--no-llama-parse") ||
-  options.template === "reflex"
+  options.template === "extractor"
 ) {
  options.useLlamaParse = false;
 }
@@ -326,6 +326,7 @@ async function run(): Promise<void> {
    ...answers,
    appPath: resolvedProjectPath,
    packageManager,
+    externalPort: options.externalPort,
  });

  if (answers.postInstallAction === "VSCode") {
@@ -354,7 +355,14 @@ Please check ${cyan(
    }
  } else if (answers.postInstallAction === "runApp") {
    console.log(`Running app in ${root}...`);
-    await runApp(root, answers.template, answers.framework, options.port);
+    await runApp(
+      root,
+      answers.template,
+      answers.frontend,
+      answers.framework,
+      options.port,
+      options.externalPort,
+    );
  }
 }

@@ -1,39 +1,86 @@
 {
-	"name": "create-llama-monorepo",
-	"version": "1.0.0",
-	"private": true,
-	"description": "Monorepo for create-llama",
-	"keywords": [
-		"rag",
-		"llamaindex"
-	],
-	"repository": {
-		"type": "git",
-		"url": "https://github.com/run-llama/create-llama"
-	},
-	"license": "MIT",
-	"workspaces": [
-		"packages/*"
-	],
-	"scripts": {
-		"prepare": "husky",
-		"new-snapshot": "pnpm -r build && changeset version --snapshot",
-		"new-version": "pnpm -r build && changeset version",
-		"release": "pnpm -r build && changeset publish",
-		"release-snapshot": "pnpm -r build && changeset publish --tag snapshot",
-		"build": "pnpm -r build",
-		"e2e": "pnpm -r e2e",
-		"dev": "pnpm -r dev",
-		"format": "pnpm -r format",
-		"format:write": "pnpm -r format:write",
-		"lint": "pnpm -r lint"
-	},
-	"devDependencies": {
-		"@changesets/cli": "^2.27.1",
-		"husky": "^9.0.10"
-	},
-	"packageManager": "pnpm@9.0.5",
-	"engines": {
-		"node": ">=16.14.0"
-	}
+  "name": "create-llama",
+  "version": "0.2.19",
+  "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"
+  ],
+  "scripts": {
+    "build": "bash ./scripts/build.sh",
+    "build:ncc": "pnpm run clean && ncc build ./index.ts -o ./dist/ --minify --no-cache --no-source-map-register",
+    "clean": "rimraf --glob ./dist ./templates/**/__pycache__ ./templates/**/node_modules ./templates/**/poetry.lock",
+    "dev": "ncc build ./index.ts -w -o dist/",
+    "e2e": "playwright test",
+    "e2e:python": "playwright test e2e/shared e2e/python",
+    "e2e:typescript": "playwright test e2e/shared e2e/typescript",
+    "format": "prettier --ignore-unknown --cache --check .",
+    "format:write": "prettier --ignore-unknown --write .",
+    "lint": "eslint . --ignore-pattern dist --ignore-pattern e2e/cache",
+    "new-snapshot": "pnpm run build && changeset version --snapshot",
+    "new-version": "pnpm run build && changeset version",
+    "pack-install": "bash ./scripts/pack.sh",
+    "prepare": "husky",
+    "release": "pnpm run build && changeset publish",
+    "release-snapshot": "pnpm run build && changeset publish --tag snapshot"
+  },
+  "dependencies": {
+    "@types/async-retry": "1.4.2",
+    "@types/ci-info": "2.0.0",
+    "@types/cross-spawn": "6.0.0",
+    "@types/fs-extra": "11.0.4",
+    "@types/node": "^20.11.7",
+    "@types/prompts": "2.0.1",
+    "@types/tar": "6.1.5",
+    "@types/validate-npm-package-name": "3.0.0",
+    "async-retry": "1.3.1",
+    "async-sema": "3.0.1",
+    "ci-info": "github:watson/ci-info#f43f6a1cefff47fb361c88cf4b943fdbcaafe540",
+    "commander": "12.1.0",
+    "cross-spawn": "7.0.3",
+    "fast-glob": "3.3.1",
+    "fs-extra": "11.2.0",
+    "global-agent": "^3.0.0",
+    "got": "10.7.0",
+    "ollama": "^0.5.0",
+    "ora": "^8.0.1",
+    "picocolors": "1.0.0",
+    "prompts": "2.4.2",
+    "smol-toml": "^1.1.4",
+    "tar": "6.1.15",
+    "terminal-link": "^3.0.0",
+    "update-check": "1.5.4",
+    "validate-npm-package-name": "3.0.0",
+    "yaml": "2.4.1"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.1",
+    "@playwright/test": "^1.41.1",
+    "@vercel/ncc": "0.38.1",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^8.10.0",
+    "husky": "^9.0.10",
+    "prettier": "^3.2.5",
+    "prettier-plugin-organize-imports": "^3.2.4",
+    "rimraf": "^5.0.5",
+    "typescript": "^5.3.3",
+    "wait-port": "^1.1.0"
+  },
+  "packageManager": "pnpm@9.0.5",
+  "engines": {
+    "node": ">=16.14.0"
+  }
 }
@@ -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
@@ -1,107 +0,0 @@
-/* eslint-disable turbo/no-undeclared-env-vars */
-import { expect, test } from "@playwright/test";
-import { ChildProcess } from "child_process";
-import fs from "fs";
-import path from "path";
-import type {
-  TemplateFramework,
-  TemplatePostInstallAction,
-  TemplateUI,
-} from "../../helpers";
-import { createTestDir, runCreateLlama, type AppType } from "../utils";
-
-const templateFramework: TemplateFramework = process.env.FRAMEWORK
-  ? (process.env.FRAMEWORK as TemplateFramework)
-  : "fastapi";
-const dataSource: string = "--example-file";
-const templateUI: TemplateUI = "shadcn";
-const templatePostInstallAction: TemplatePostInstallAction = "runApp";
-const appType: AppType = "--frontend";
-const userMessage = "Write a blog post about physical standards for letters";
-const templateUseCases = ["financial_report", "agentic_rag", "deep_research"];
-
-for (const useCase of templateUseCases) {
-  test.describe(`Test use case ${useCase} ${templateFramework} ${dataSource} ${templateUI} ${appType} ${templatePostInstallAction}`, async () => {
-    test.skip(
-      process.platform !== "linux" ||
-        process.env.DATASOURCE === "--no-files" ||
-        templateFramework === "express",
-      "The llamaindexserver template currently only works with nextjs, fastapi. We also only run on Linux to speed up tests.",
-    );
-    let port: number;
-    let cwd: string;
-    let name: string;
-    let appProcess: ChildProcess;
-    // Only test without using vector db for now
-    const vectorDb = "none";
-
-    test.beforeAll(async () => {
-      port = Math.floor(Math.random() * 10000) + 10000;
-      cwd = await createTestDir();
-      const result = await runCreateLlama({
-        cwd,
-        templateType: "llamaindexserver",
-        templateFramework,
-        dataSource,
-        vectorDb,
-        port,
-        postInstallAction: templatePostInstallAction,
-        templateUI,
-        appType,
-        useCase,
-      });
-      name = result.projectName;
-      appProcess = result.appProcess;
-    });
-
-    test("App folder should exist", async () => {
-      const dirExists = fs.existsSync(path.join(cwd, name));
-      expect(dirExists).toBeTruthy();
-    });
-
-    test("Frontend should have a title", async ({ page }) => {
-      test.skip(
-        templatePostInstallAction !== "runApp" ||
-          templateFramework === "express",
-      );
-      await page.goto(`http://localhost:${port}`);
-      await expect(page.getByText("Built by LlamaIndex")).toBeVisible({
-        timeout: 5 * 60 * 1000,
-      });
-    });
-
-    test("Frontend should be able to submit a message and receive the start of a streamed response", async ({
-      page,
-    }) => {
-      test.skip(
-        templatePostInstallAction !== "runApp" ||
-          useCase === "financial_report" ||
-          useCase === "deep_research" ||
-          templateFramework === "express",
-        "Skip chat tests for financial report and deep research.",
-      );
-      await page.goto(`http://localhost:${port}`);
-      await page.fill("form textarea", userMessage);
-
-      const responsePromise = page.waitForResponse((res) =>
-        res.url().includes("/api/chat"),
-      );
-
-      await page.click("form button[type=submit]");
-
-      const response = await responsePromise;
-      console.log(`Response status: ${response.status()}`);
-      const responseBody = await response
-        .text()
-        .catch((e) => `Error reading body: ${e}`);
-      console.log(`Response body: ${responseBody}`);
-
-      expect(response.ok()).toBeTruthy();
-    });
-
-    // clean processes
-    test.afterAll(async () => {
-      appProcess?.kill();
-    });
-  });
-}
@@ -1,64 +0,0 @@
-/* eslint-disable turbo/no-undeclared-env-vars */
-import { expect, test } from "@playwright/test";
-import { ChildProcess } from "child_process";
-import fs from "fs";
-import path from "path";
-import { TemplateFramework, TemplateUseCase } from "../../helpers";
-import { createTestDir, runCreateLlama } from "../utils";
-
-const templateFramework: TemplateFramework = process.env.FRAMEWORK
-  ? (process.env.FRAMEWORK as TemplateFramework)
-  : "fastapi";
-const dataSource: string = process.env.DATASOURCE
-  ? process.env.DATASOURCE
-  : "--example-file";
-const templateUseCases: TemplateUseCase[] = ["extractor", "contract_review"];
-
-// The reflex template currently only works with FastAPI and files (and not on Windows)
-if (
-  process.platform !== "win32" &&
-  templateFramework === "fastapi" &&
-  dataSource === "--example-file"
-) {
-  for (const useCase of templateUseCases) {
-    test.describe(`Test reflex template ${useCase} ${templateFramework} ${dataSource}`, async () => {
-      let appPort: number;
-      let name: string;
-      let appProcess: ChildProcess;
-      let cwd: string;
-
-      // Create reflex app
-      test.beforeAll(async () => {
-        cwd = await createTestDir();
-        appPort = Math.floor(Math.random() * 10000) + 10000;
-        const result = await runCreateLlama({
-          cwd,
-          templateType: "reflex",
-          templateFramework: "fastapi",
-          dataSource: "--example-file",
-          vectorDb: "none",
-          port: appPort,
-          postInstallAction: "runApp",
-          useCase,
-        });
-        name = result.projectName;
-        appProcess = result.appProcess;
-      });
-
-      test.afterAll(async () => {
-        appProcess.kill();
-      });
-
-      test("App folder should exist", async () => {
-        const dirExists = fs.existsSync(path.join(cwd, name));
-        expect(dirExists).toBeTruthy();
-      });
-      test("Frontend should have a title", async ({ page }) => {
-        await page.goto(`http://localhost:${appPort}`);
-        await expect(page.getByText("Built by LlamaIndex")).toBeVisible({
-          timeout: 2000 * 60,
-        });
-      });
-    });
-  }
-}
@@ -1,68 +0,0 @@
-import prompts from "prompts";
-import { ModelConfigParams } from ".";
-import { questionHandlers, toChoice } from "../../questions/utils";
-
-const MODELS = ["HuggingFaceH4/zephyr-7b-alpha"];
-type ModelData = {
-  dimensions: number;
-};
-const EMBEDDING_MODELS: Record<string, ModelData> = {
-  "BAAI/bge-small-en-v1.5": { dimensions: 384 },
-  "BAAI/bge-base-en-v1.5": { dimensions: 768 },
-  "BAAI/bge-large-en-v1.5": { dimensions: 1024 },
-  "sentence-transformers/all-MiniLM-L6-v2": { dimensions: 384 },
-  "sentence-transformers/all-mpnet-base-v2": { dimensions: 768 },
-  "intfloat/multilingual-e5-large": { dimensions: 1024 },
-  "mixedbread-ai/mxbai-embed-large-v1": { dimensions: 1024 },
-  "nomic-ai/nomic-embed-text-v1.5": { dimensions: 768 },
-};
-
-const DEFAULT_MODEL = MODELS[0];
-const DEFAULT_EMBEDDING_MODEL = Object.keys(EMBEDDING_MODELS)[0];
-const DEFAULT_DIMENSIONS = Object.values(EMBEDDING_MODELS)[0].dimensions;
-
-type HuggingfaceQuestionsParams = {
-  askModels: boolean;
-};
-
-export async function askHuggingfaceQuestions({
-  askModels,
-}: HuggingfaceQuestionsParams): Promise<ModelConfigParams> {
-  const config: ModelConfigParams = {
-    model: DEFAULT_MODEL,
-    embeddingModel: DEFAULT_EMBEDDING_MODEL,
-    dimensions: DEFAULT_DIMENSIONS,
-    isConfigured(): boolean {
-      return true;
-    },
-  };
-
-  if (askModels) {
-    const { model } = await prompts(
-      {
-        type: "select",
-        name: "model",
-        message: "Which Hugging Face model would you like to use?",
-        choices: MODELS.map(toChoice),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.model = model;
-
-    const { embeddingModel } = await prompts(
-      {
-        type: "select",
-        name: "embeddingModel",
-        message: "Which embedding model would you like to use?",
-        choices: Object.keys(EMBEDDING_MODELS).map(toChoice),
-        initial: 0,
-      },
-      questionHandlers,
-    );
-    config.embeddingModel = embeddingModel;
-    config.dimensions = EMBEDDING_MODELS[embeddingModel].dimensions;
-  }
-
-  return config;
-}
@@ -1,91 +0,0 @@
-import { SpawnOptions, spawn } from "child_process";
-import { TemplateFramework, TemplateType } from "./types";
-
-const createProcess = (
-  command: string,
-  args: string[],
-  options: SpawnOptions,
-): Promise<void> => {
-  return new Promise((resolve, reject) => {
-    spawn(command, args, {
-      ...options,
-      shell: true,
-    })
-      .on("exit", function (code) {
-        if (code !== 0) {
-          console.log(`Child process exited with code=${code}`);
-          reject(code);
-        } else {
-          resolve();
-        }
-      })
-      .on("error", function (err) {
-        console.log("Error when running child process: ", err);
-        reject(err);
-      });
-  });
-};
-
-export function runReflexApp(appPath: string, port: number) {
-  const commandArgs = [
-    "run",
-    "reflex",
-    "run",
-    "--frontend-port",
-    port.toString(),
-  ];
-  return createProcess("uv", commandArgs, {
-    stdio: "inherit",
-    cwd: appPath,
-  });
-}
-
-export function runFastAPIApp(
-  appPath: string,
-  port: number,
-  template: TemplateType,
-) {
-  let commandArgs: string[];
-  if (template === "streaming") {
-    commandArgs = ["run", "dev"];
-  } else {
-    commandArgs = ["run", "fastapi", "dev", "--port", `${port}`];
-  }
-  return createProcess("uv", commandArgs, {
-    stdio: "inherit",
-    cwd: appPath,
-    env: { ...process.env, APP_PORT: `${port}` },
-  });
-}
-
-export function runTSApp(appPath: string, port: number) {
-  return createProcess("npm", ["run", "dev"], {
-    stdio: "inherit",
-    cwd: appPath,
-    env: { ...process.env, PORT: `${port}` },
-  });
-}
-
-export async function runApp(
-  appPath: string,
-  template: TemplateType,
-  framework: TemplateFramework,
-  port?: number,
-): Promise<void> {
-  try {
-    // Start the app
-    const defaultPort =
-      framework === "nextjs" || template === "reflex" ? 3000 : 8000;
-
-    const appRunner =
-      template === "reflex"
-        ? runReflexApp
-        : framework === "fastapi"
-          ? runFastAPIApp
-          : runTSApp;
-    await appRunner(appPath, port || defaultPort, template);
-  } catch (error) {
-    console.error("Failed to run app:", error);
-    throw error;
-  }
-}
@@ -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;
-}
@@ -1,83 +0,0 @@
-{
-  "name": "create-llama",
-  "version": "0.5.11",
-  "description": "Create LlamaIndex-powered apps with one command",
-  "keywords": [
-    "rag",
-    "llamaindex",
-    "next.js"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/run-llama/create-llama",
-    "directory": "packages/create-llama"
-  },
-  "license": "MIT",
-  "bin": {
-    "create-llama": "./dist/index.js"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE.md"
-  ],
-  "scripts": {
-    "copy": "cp -r ../../README.md ../../LICENSE.md .",
-    "build": "bash ./scripts/build.sh",
-    "build:ncc": "pnpm run clean && ncc build ./index.ts -o ./dist/ --minify --no-cache --no-source-map-register",
-    "postbuild": "pnpm run copy",
-    "clean": "rimraf --glob ./dist ./templates/**/__pycache__ ./templates/**/node_modules ./templates/**/poetry.lock",
-    "dev": "ncc build ./index.ts -w -o dist/",
-    "e2e": "playwright test",
-    "e2e:python": "playwright test e2e/shared e2e/python",
-    "e2e:typescript": "playwright test e2e/shared e2e/typescript",
-    "format": "prettier --ignore-unknown --cache --check .",
-    "format:write": "prettier --ignore-unknown --write .",
-    "lint": "eslint . --ignore-pattern dist --ignore-pattern e2e/cache",
-    "pack-install": "bash ./scripts/pack.sh"
-  },
-  "dependencies": {
-    "@types/async-retry": "1.4.2",
-    "@types/ci-info": "2.0.0",
-    "@types/cross-spawn": "6.0.0",
-    "@types/fs-extra": "11.0.4",
-    "@types/node": "^20.11.7",
-    "@types/prompts": "2.4.2",
-    "@types/tar": "6.1.5",
-    "@types/validate-npm-package-name": "3.0.0",
-    "async-retry": "1.3.1",
-    "async-sema": "3.0.1",
-    "ci-info": "github:watson/ci-info#f43f6a1cefff47fb361c88cf4b943fdbcaafe540",
-    "commander": "12.1.0",
-    "cross-spawn": "7.0.3",
-    "fast-glob": "3.3.1",
-    "fs-extra": "11.2.0",
-    "global-agent": "^3.0.0",
-    "got": "10.7.0",
-    "ollama": "^0.5.0",
-    "ora": "^8.0.1",
-    "picocolors": "1.0.0",
-    "prompts": "2.4.2",
-    "smol-toml": "^1.1.4",
-    "tar": "6.1.15",
-    "terminal-link": "^3.0.0",
-    "update-check": "1.5.4",
-    "validate-npm-package-name": "3.0.0",
-    "yaml": "2.4.1"
-  },
-  "devDependencies": {
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^8.10.0",
-    "prettier": "^3.2.5",
-    "prettier-plugin-organize-imports": "^3.2.4",
-    "@playwright/test": "^1.41.1",
-    "@vercel/ncc": "0.38.1",
-    "rimraf": "^5.0.5",
-    "typescript": "^5.3.3",
-    "wait-port": "^1.1.0"
-  },
-  "packageManager": "pnpm@9.0.5",
-  "engines": {
-    "node": ">=16.14.0"
-  }
-}
@@ -1,3 +0,0 @@
-from .blog import create_workflow
-
-__all__ = ["create_workflow"]
@@ -1,47 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) multi-agents project using [Workflows](https://docs.llamaindex.ai/en/stable/understanding/workflows/).
-
-## Getting Started
-
-First, setup the environment with poetry:
-
-> **_Note:_** This step is not needed if you are using the dev-container.
-
-```shell
-uv sync
-```
-
-Then check the parameters that have been pre-configured in the `.env` file in this directory. (E.g. you might need to configure an `OPENAI_API_KEY` if you're using OpenAI as model provider).
-Second, generate the embeddings of the documents in the `./data` directory:
-
-```shell
-uv run generate
-```
-
-Third, run the development server:
-
-```shell
-uv run dev
-```
-
-## Use Case: Deep Research over own documents
-
-The workflow performs deep research by retrieving and analyzing documents from the [data](./data) directory from multiple perspectives. The project includes a sample PDF about AI investment in 2024 to help you get started. You can also add your own documents by placing them in the data directory and running the generate script again to index them.
-
-After starting the server, go to [http://localhost:8000](http://localhost:8000) and send a message to the agent to write a blog post.
-E.g: "AI investment in 2024"
-
-To update the workflow, you can edit the [deep_research.py](./app/workflows/deep_research.py) file.
-
-By default, the workflow retrieves 10 results from your documents. To customize the amount of information covered in the answer, you can adjust the `TOP_K` environment variable in the `.env` file. A higher value will retrieve more results from your documents, potentially providing more comprehensive answers.
-
-## Deployments
-
-For production deployments, check the [DEPLOY.md](DEPLOY.md) file.
-
-## Learn More
-
-To learn more about LlamaIndex, take a look at the following resources:
-
- [LlamaIndex Documentation](https://docs.llamaindex.ai) - learn about LlamaIndex.
- [Workflows Introduction](https://docs.llamaindex.ai/en/stable/understanding/workflows/) - learn about LlamaIndex workflows.
-  You can check out [the LlamaIndex GitHub repository](https://github.com/run-llama/llama_index) - your feedback and contributions are welcome!
@@ -1,3 +0,0 @@
-from .deep_research import create_workflow
-
-__all__ = ["create_workflow"]
@@ -1,183 +0,0 @@
-from typing import List, Literal, Optional
-
-from llama_index.core.base.llms.types import (
-    CompletionResponse,
-    CompletionResponseAsyncGen,
-)
-from llama_index.core.memory.simple_composable_memory import SimpleComposableMemory
-from llama_index.core.prompts import PromptTemplate
-from llama_index.core.schema import MetadataMode, Node, NodeWithScore
-from llama_index.core.settings import Settings
-from pydantic import BaseModel, Field
-
-
-class AnalysisDecision(BaseModel):
-    decision: Literal["research", "write", "cancel"] = Field(
-        description="Whether to continue research, write a report, or cancel the research after several retries"
-    )
-    research_questions: Optional[List[str]] = Field(
-        description="""
-        If the decision is to research, provide a list of questions to research that related to the user request.
-        Maximum 3 questions. Set to null or empty if writing a report or cancel the research.
-        """,
-        default_factory=list,
-    )
-    cancel_reason: Optional[str] = Field(
-        description="The reason for cancellation if the decision is to cancel research.",
-        default=None,
-    )
-
-
-async def plan_research(
-    memory: SimpleComposableMemory,
-    context_nodes: List[Node],
-    user_request: str,
-    total_questions: int,
-) -> AnalysisDecision:
-    analyze_prompt = """
-      You are a professor who is guiding a researcher to research a specific request/problem.
-      Your task is to decide on a research plan for the researcher.
-
-      The possible actions are:
-      + Provide a list of questions for the researcher to investigate, with the purpose of clarifying the request.
-      + Write a report if the researcher has already gathered enough research on the topic and can resolve the initial request.
-      + Cancel the research if most of the answers from researchers indicate there is insufficient information to research the request. Do not attempt more than 3 research iterations or too many questions.
-
-      The workflow should be:
-      + Always begin by providing some initial questions for the researcher to investigate.
-      + Analyze the provided answers against the initial topic/request. If the answers are insufficient to resolve the initial request, provide additional questions for the researcher to investigate.
-      + If the answers are sufficient to resolve the initial request, instruct the researcher to write a report.
-
-      Here are the context: 
-      <Collected information>
-      {context_str}
-      </Collected information>
-
-      <Conversation context>
-      {conversation_context}
-      </Conversation context>
-
-      {enhanced_prompt}
-
-      Now, provide your decision in the required format for this user request:
-      <User request>
-      {user_request}
-      </User request>
-      """
-    # Manually craft the prompt to avoid LLM hallucination
-    enhanced_prompt = ""
-    if total_questions == 0:
-        # Avoid writing a report without any research context
-        enhanced_prompt = """
-        
-        The student has no questions to research. Let start by asking some questions.
-        """
-    elif total_questions > 6:
-        # Avoid asking too many questions (when the data is not ready for writing a report)
-        enhanced_prompt = f"""
-
-        The student has researched {total_questions} questions. Should cancel the research if the context is not enough to write a report.
-        """
-
-    conversation_context = "\n".join(
-        [f"{message.role}: {message.content}" for message in memory.get_all()]
-    )
-    context_str = "\n".join(
-        [node.get_content(metadata_mode=MetadataMode.LLM) for node in context_nodes]
-    )
-    res = await Settings.llm.astructured_predict(
-        output_cls=AnalysisDecision,
-        prompt=PromptTemplate(template=analyze_prompt),
-        user_request=user_request,
-        context_str=context_str,
-        conversation_context=conversation_context,
-        enhanced_prompt=enhanced_prompt,
-    )
-    return res
-
-
-async def research(
-    question: str,
-    context_nodes: List[NodeWithScore],
-) -> str:
-    prompt = """
-    You are a researcher who is in the process of answering the question.
-    The purpose is to answer the question based on the collected information, without using prior knowledge or making up any new information.
-    Always add citations to the sentence/point/paragraph using the id of the provided content.
-    The citation should follow this format: [citation:id]() where id is the id of the content.
-    
-    E.g:
-    If we have a context like this:
-    <Citation id='abc-xyz'>
-    Baby llama is called cria
-    </Citation id='abc-xyz'>
-
-    And your answer uses the content, then the citation should be:
-    - Baby llama is called cria [citation:abc-xyz]()
-
-    Here is the provided context for the question:
-    <Collected information>
-    {context_str}
-    </Collected information>`
-
-    No prior knowledge, just use the provided context to answer the question: {question}
-    """
-    context_str = "\n".join(
-        [_get_text_node_content_for_citation(node) for node in context_nodes]
-    )
-    res = await Settings.llm.acomplete(
-        prompt=prompt.format(question=question, context_str=context_str),
-    )
-    return res.text
-
-
-async def write_report(
-    memory: SimpleComposableMemory,
-    user_request: str,
-    stream: bool = False,
-) -> CompletionResponse | CompletionResponseAsyncGen:
-    report_prompt = """
-    You are a researcher writing a report based on a user request and the research context.
-    You have researched various perspectives related to the user request.
-    The report should provide a comprehensive outline covering all important points from the researched perspectives.
-    Create a well-structured outline for the research report that covers all the answers.
-
-    # IMPORTANT when writing in markdown format:
-    + Use tables or figures where appropriate to enhance presentation.
-    + Preserve all citation syntax (the `[citation:id]()` parts in the provided context). Keep these citations in the final report - no separate reference section is needed.
-    + Do not add links, a table of contents, or a references section to the report.
-
-    <User request>
-    {user_request}
-    </User request>
-
-    <Research context>
-    {research_context}
-    </Research context>
-
-    Now, write a report addressing the user request based on the research provided following the format and guidelines above.
-    """
-    research_context = "\n".join(
-        [f"{message.role}: {message.content}" for message in memory.get_all()]
-    )
-
-    llm_complete_func = (
-        Settings.llm.astream_complete if stream else Settings.llm.acomplete
-    )
-
-    res = await llm_complete_func(
-        prompt=report_prompt.format(
-            user_request=user_request,
-            research_context=research_context,
-        ),
-    )
-    return res
-
-
-def _get_text_node_content_for_citation(node: NodeWithScore) -> str:
-    """
-    Construct node content for LLM with citation flag.
-    """
-    node_id = node.node.node_id
-    content = f"<Citation id='{node_id}'>\n{node.get_content(metadata_mode=MetadataMode.LLM)}</Citation id='{node_id}'>"
-    return content
@@ -1,328 +0,0 @@
-import logging
-import os
-import uuid
-from typing import Any, Dict, List, Optional
-
-from llama_index.core.indices.base import BaseIndex
-from llama_index.core.memory import ChatMemoryBuffer
-from llama_index.core.memory.simple_composable_memory import SimpleComposableMemory
-from llama_index.core.schema import Node
-from llama_index.core.types import ChatMessage, MessageRole
-from llama_index.core.workflow import (
-    Context,
-    StartEvent,
-    StopEvent,
-    Workflow,
-    step,
-)
-
-from app.engine.index import IndexConfig, get_index
-from app.workflows.agents import plan_research, research, write_report
-from app.workflows.events import SourceNodesEvent
-from app.workflows.models import (
-    CollectAnswersEvent,
-    DataEvent,
-    PlanResearchEvent,
-    ReportEvent,
-    ResearchEvent,
-)
-
-logger = logging.getLogger("uvicorn")
-logger.setLevel(logging.INFO)
-
-
-def create_workflow(
-    params: Optional[Dict[str, Any]] = None,
-    **kwargs,
-) -> Workflow:
-    index_config = IndexConfig(**params)
-    index = get_index(index_config)
-    if index is None:
-        raise ValueError(
-            "Index is not found. Try run generation script to create the index first."
-        )
-
-    return DeepResearchWorkflow(
-        index=index,
-        timeout=120.0,
-    )
-
-
-class DeepResearchWorkflow(Workflow):
-    """
-    A workflow to research and analyze documents from multiple perspectives and write a comprehensive report.
-
-    Requirements:
-    - An indexed documents containing the knowledge base related to the topic
-
-    Steps:
-    1. Retrieve information from the knowledge base
-    2. Analyze the retrieved information and provide questions for answering
-    3. Answer the questions
-    4. Write the report based on the research results
-    """
-
-    memory: SimpleComposableMemory
-    context_nodes: List[Node]
-    index: BaseIndex
-    user_request: str
-    stream: bool = True
-
-    def __init__(
-        self,
-        index: BaseIndex,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-        self.index = index
-        self.context_nodes = []
-        self.memory = SimpleComposableMemory.from_defaults(
-            primary_memory=ChatMemoryBuffer.from_defaults(),
-        )
-
-    @step
-    async def retrieve(self, ctx: Context, ev: StartEvent) -> PlanResearchEvent:
-        """
-        Initiate the workflow: memory, tools, agent
-        """
-        self.stream = ev.get("stream", True)
-        self.user_request = ev.get("user_msg")
-        chat_history = ev.get("chat_history")
-        if chat_history is not None:
-            self.memory.put_messages(chat_history)
-
-        await ctx.set("total_questions", 0)
-
-        # Add user message to memory
-        self.memory.put_messages(
-            messages=[
-                ChatMessage(
-                    role=MessageRole.USER,
-                    content=self.user_request,
-                )
-            ]
-        )
-        ctx.write_event_to_stream(
-            DataEvent(
-                type="deep_research_event",
-                data={
-                    "event": "retrieve",
-                    "state": "inprogress",
-                },
-            )
-        )
-        retriever = self.index.as_retriever(
-            similarity_top_k=int(os.getenv("TOP_K", 10)),
-        )
-        nodes = retriever.retrieve(self.user_request)
-        self.context_nodes.extend(nodes)
-        ctx.write_event_to_stream(
-            DataEvent(
-                type="deep_research_event",
-                data={
-                    "event": "retrieve",
-                    "state": "done",
-                },
-            )
-        )
-        # Send source nodes to the stream
-        # Use SourceNodesEvent to display source nodes in the UI.
-        ctx.write_event_to_stream(
-            SourceNodesEvent(
-                nodes=nodes,
-            )
-        )
-        return PlanResearchEvent()
-
-    @step
-    async def analyze(
-        self, ctx: Context, ev: PlanResearchEvent
-    ) -> ResearchEvent | ReportEvent | StopEvent:
-        """
-        Analyze the retrieved information
-        """
-        logger.info("Analyzing the retrieved information")
-        ctx.write_event_to_stream(
-            DataEvent(
-                type="deep_research_event",
-                data={
-                    "event": "analyze",
-                    "state": "inprogress",
-                },
-            )
-        )
-        total_questions = await ctx.get("total_questions")
-        res = await plan_research(
-            memory=self.memory,
-            context_nodes=self.context_nodes,
-            user_request=self.user_request,
-            total_questions=total_questions,
-        )
-        if res.decision == "cancel":
-            ctx.write_event_to_stream(
-                DataEvent(
-                    type="deep_research_event",
-                    data={
-                        "event": "analyze",
-                        "state": "done",
-                    },
-                )
-            )
-            return StopEvent(
-                result=res.cancel_reason,
-            )
-        elif res.decision == "write":
-            # Writing a report without any research context is not allowed.
-            # It's a LLM hallucination.
-            if total_questions == 0:
-                ctx.write_event_to_stream(
-                    DataEvent(
-                        type="deep_research_event",
-                        data={
-                            "event": "analyze",
-                            "state": "done",
-                        },
-                    )
-                )
-                return StopEvent(
-                    result="Sorry, I have a problem when analyzing the retrieved information. Please try again.",
-                )
-
-            self.memory.put(
-                message=ChatMessage(
-                    role=MessageRole.ASSISTANT,
-                    content="No more idea to analyze. We should report the answers.",
-                )
-            )
-            ctx.send_event(ReportEvent())
-        else:
-            total_questions += len(res.research_questions)
-            await ctx.set("total_questions", total_questions)  # For tracking
-            await ctx.set(
-                "waiting_questions", len(res.research_questions)
-            )  # For waiting questions to be answered
-            self.memory.put(
-                message=ChatMessage(
-                    role=MessageRole.ASSISTANT,
-                    content="We need to find answers to the following questions:\n"
-                    + "\n".join(res.research_questions),
-                )
-            )
-            for question in res.research_questions:
-                question_id = str(uuid.uuid4())
-                ctx.write_event_to_stream(
-                    DataEvent(
-                        type="deep_research_event",
-                        data={
-                            "event": "answer",
-                            "state": "pending",
-                            "id": question_id,
-                            "question": question,
-                            "answer": None,
-                        },
-                    )
-                )
-                ctx.send_event(
-                    ResearchEvent(
-                        question_id=question_id,
-                        question=question,
-                        context_nodes=self.context_nodes,
-                    )
-                )
-        ctx.write_event_to_stream(
-            DataEvent(
-                type="deep_research_event",
-                data={
-                    "event": "analyze",
-                    "state": "done",
-                },
-            )
-        )
-        return None
-
-    @step(num_workers=2)
-    async def answer(self, ctx: Context, ev: ResearchEvent) -> CollectAnswersEvent:
-        """
-        Answer the question
-        """
-        ctx.write_event_to_stream(
-            DataEvent(
-                type="deep_research_event",
-                data={
-                    "event": "answer",
-                    "state": "inprogress",
-                    "id": ev.question_id,
-                    "question": ev.question,
-                },
-            )
-        )
-        try:
-            answer = await research(
-                context_nodes=ev.context_nodes,
-                question=ev.question,
-            )
-        except Exception as e:
-            logger.error(f"Error answering question {ev.question}: {e}")
-            answer = f"Got error when answering the question: {ev.question}"
-        ctx.write_event_to_stream(
-            DataEvent(
-                type="deep_research_event",
-                data={
-                    "event": "answer",
-                    "state": "done",
-                    "id": ev.question_id,
-                    "question": ev.question,
-                    "answer": answer,
-                },
-            )
-        )
-
-        return CollectAnswersEvent(
-            question_id=ev.question_id,
-            question=ev.question,
-            answer=answer,
-        )
-
-    @step
-    async def collect_answers(
-        self, ctx: Context, ev: CollectAnswersEvent
-    ) -> PlanResearchEvent:
-        """
-        Collect answers to all questions
-        """
-        num_questions = await ctx.get("waiting_questions")
-        results = ctx.collect_events(
-            ev,
-            expected=[CollectAnswersEvent] * num_questions,
-        )
-        if results is None:
-            return None
-        for result in results:
-            self.memory.put(
-                message=ChatMessage(
-                    role=MessageRole.ASSISTANT,
-                    content=f"<Question>{result.question}</Question>\n<Answer>{result.answer}</Answer>",
-                )
-            )
-        await ctx.set("waiting_questions", 0)
-        self.memory.put(
-            message=ChatMessage(
-                role=MessageRole.ASSISTANT,
-                content="Researched all the questions. Now, i need to analyze if it's ready to write a report or need to research more.",
-            )
-        )
-        return PlanResearchEvent()
-
-    @step
-    async def report(self, ctx: Context, ev: ReportEvent) -> StopEvent:
-        """
-        Report the answers
-        """
-        res = await write_report(
-            memory=self.memory,
-            user_request=self.user_request,
-            stream=self.stream,
-        )
-        return StopEvent(
-            result=res,
-        )
@@ -1,43 +0,0 @@
-from typing import List, Literal, Optional
-
-from llama_index.core.schema import NodeWithScore
-from llama_index.core.workflow import Event
-from pydantic import BaseModel
-
-
-# Workflow events
-class PlanResearchEvent(Event):
-    pass
-
-
-class ResearchEvent(Event):
-    question_id: str
-    question: str
-    context_nodes: List[NodeWithScore]
-
-
-class CollectAnswersEvent(Event):
-    question_id: str
-    question: str
-    answer: str
-
-
-class ReportEvent(Event):
-    pass
-
-
-# Events that are streamed to the frontend and rendered there
-class DeepResearchEventData(BaseModel):
-    event: Literal["retrieve", "analyze", "answer"]
-    state: Literal["pending", "inprogress", "done", "error"]
-    id: Optional[str] = None
-    question: Optional[str] = None
-    answer: Optional[str] = None
-
-
-class DataEvent(Event):
-    type: Literal["deep_research_event"]
-    data: DeepResearchEventData
-
-    def to_response(self):
-        return self.model_dump()
@@ -1,57 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) multi-agents project using [Workflows](https://docs.llamaindex.ai/en/stable/understanding/workflows/).
-
-## Getting Started
-
-First, setup the environment with poetry:
-
-> **_Note:_** This step is not needed if you are using the dev-container.
-
-```shell
-uv sync
-```
-
-Then check the parameters that have been pre-configured in the `.env` file in this directory. (E.g. you might need to configure an `OPENAI_API_KEY` if you're using OpenAI as model provider and `E2B_API_KEY` for the [E2B's code interpreter tool](https://e2b.dev/docs)).
-
-Second, generate the embeddings of the documents in the `./data` directory:
-
-```shell
-uv run generate
-```
-
-Third, run the development server:
-
-```shell
-uv run dev
-```
-
-The example provides one streaming API endpoint `/api/chat`.
-You can test the endpoint with the following curl request:
-
-```
-curl --location 'localhost:8000/api/chat' \
--header 'Content-Type: application/json' \
--data '{ "messages": [{ "role": "user", "content": "Create a report comparing the finances of Apple and Tesla" }] }'
-```
-
-You can start editing the API by modifying `app/api/routers/chat.py` or `app/workflows/financial_report.py`. The API auto-updates as you save the files.
-
-Open [http://localhost:8000](http://localhost:8000) with your browser to start the app.
-
-To start the app optimized for **production**, run:
-
-```
-uv run prod
-```
-
-## Deployments
-
-For production deployments, check the [DEPLOY.md](DEPLOY.md) file.
-
-## Learn More
-
-To learn more about LlamaIndex, take a look at the following resources:
-
- [LlamaIndex Documentation](https://docs.llamaindex.ai) - learn about LlamaIndex.
- [Workflows Introduction](https://docs.llamaindex.ai/en/stable/understanding/workflows/) - learn about LlamaIndex workflows.
-
-You can check out [the LlamaIndex GitHub repository](https://github.com/run-llama/llama_index) - your feedback and contributions are welcome!
@@ -1,3 +0,0 @@
-from .financial_report import create_workflow
-
-__all__ = ["create_workflow"]
@@ -1,300 +0,0 @@
-from typing import Any, Dict, List, Optional
-
-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 app.engine.index import IndexConfig, get_index
-from app.engine.tools import ToolFactory
-from app.engine.tools.query_engine import get_query_engine_tool
-from app.workflows.events import AgentRunEvent
-from app.workflows.tools import (
-    call_tools,
-    chat_with_tools,
-)
-
-
-def create_workflow(
-    params: Optional[Dict[str, Any]] = None,
-    **kwargs,
-) -> Workflow:
-    # Create query engine tool
-    index_config = IndexConfig(**params)
-    index = get_index(index_config)
-    if index is None:
-        raise ValueError(
-            "Index is not found. Try run generation script to create the index first."
-        )
-    query_engine_tool = get_query_engine_tool(index=index)
-
-    configured_tools: Dict[str, FunctionTool] = ToolFactory.from_env(map_result=True)  # type: ignore
-    code_interpreter_tool = configured_tools.get("interpret")
-    document_generator_tool = configured_tools.get("generate_document")
-
-    return FinancialReportWorkflow(
-        query_engine_tool=query_engine_tool,
-        code_interpreter_tool=code_interpreter_tool,
-        document_generator_tool=document_generator_tool,
-    )
-
-
-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,
-        timeout: int = 360,
-        system_prompt: Optional[str] = None,
-    ):
-        super().__init__(timeout=timeout)
-        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
-        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())
-        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_messages = await call_tools(
-            ctx=ctx,
-            agent_name="Researcher",
-            tools=[self.query_engine_tool],
-            tool_calls=tool_calls,
-        )
-        self.memory.put_messages(tool_messages)
-        return AnalyzeEvent(
-            input=ChatMessage(
-                role=MessageRole.ASSISTANT,
-                content="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
-                analyst_msg = ChatMessage(
-                    role=MessageRole.ASSISTANT,
-                    content=await response.full_response(),
-                )
-                self.memory.put(analyst_msg)
-                return InputEvent(input=self.memory.get())
-            else:
-                # Set the tool calls and the tool call message to the memory
-                tool_calls = response.tool_calls
-                self.memory.put(response.tool_call_message)
-
-        # Call tools
-        tool_messages = await call_tools(
-            ctx=ctx,
-            agent_name="Analyst",
-            tools=[self.code_interpreter_tool],
-            tool_calls=tool_calls,  # type: ignore
-        )
-        self.memory.put_messages(tool_messages)
-
-        # 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_messages = await call_tools(
-            ctx=ctx,
-            agent_name="Reporter",
-            tools=[self.document_generator_tool],
-            tool_calls=tool_calls,
-        )
-        self.memory.put_messages(tool_messages)
-
-        # After the tool calls, fallback to the input with the latest chat history
-        return InputEvent(input=self.memory.get())
@@ -1,63 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) multi-agents project using [Workflows](https://docs.llamaindex.ai/en/stable/understanding/workflows/).
-
-## Getting Started
-
-First, setup the environment with poetry:
-
-> **_Note:_** This step is not needed if you are using the dev-container.
-
-```shell
-uv sync
-```
-
-Then check the parameters that have been pre-configured in the `.env` file in this directory.
-Make sure you have the `OPENAI_API_KEY` set.
-
-Second, run the development server:
-
-```shell
-uv run dev
-```
-
-## Use Case: Filling Financial CSV Template
-
-To reproduce the use case, start the [frontend](../frontend/README.md) and follow these steps in the frontend:
-
-1. Upload the Apple and Tesla financial reports from the [data](./data) directory. Just send an empty message.
-2. Upload the CSV file [sec_10k_template.csv](./sec_10k_template.csv) and send the message "Fill the missing cells in the CSV file".
-
-The agent will fill the missing cells by retrieving the information from the uploaded financial reports and return a new CSV file with the filled cells.
-
-### API endpoints
-
-The example provides one streaming API endpoint `/api/chat`.
-You can test the endpoint with the following curl request:
-
-```
-curl --location 'localhost:8000/api/chat' \
--header 'Content-Type: application/json' \
--data '{ "messages": [{ "role": "user", "content": "What can you do?" }] }'
-```
-
-You can start editing the API by modifying `app/api/routers/chat.py` or `app/workflows/form_filling.py`. The API auto-updates as you save the files.
-
-Open [http://localhost:8000](http://localhost:8000) with your browser to start the app.
-
-To start the app optimized for **production**, run:
-
-```
-uv run prod
-```
-
-## Deployments
-
-For production deployments, check the [DEPLOY.md](DEPLOY.md) file.
-
-## Learn More
-
-To learn more about LlamaIndex, take a look at the following resources:
-
- [LlamaIndex Documentation](https://docs.llamaindex.ai) - learn about LlamaIndex.
- [Workflows Introduction](https://docs.llamaindex.ai/en/stable/understanding/workflows/) - learn about LlamaIndex workflows.
-
-You can check out [the LlamaIndex GitHub repository](https://github.com/run-llama/llama_index) - your feedback and contributions are welcome!
@@ -1,3 +0,0 @@
-from .form_filling import create_workflow
-
-__all__ = ["create_workflow"]
@@ -1,236 +0,0 @@
-from typing import Any, Dict, List, Optional
-
-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 app.engine.index import IndexConfig, get_index
-from app.engine.tools import ToolFactory
-from app.engine.tools.query_engine import get_query_engine_tool
-from app.workflows.events import AgentRunEvent
-from app.workflows.tools import (
-    call_tools,
-    chat_with_tools,
-)
-
-
-def create_workflow(
-    params: Optional[Dict[str, Any]] = None,
-    **kwargs,
-) -> Workflow:
-    # Create query engine tool
-    index_config = IndexConfig(**params)
-    index = get_index(index_config)
-    if index is None:
-        query_engine_tool = None
-    else:
-        query_engine_tool = get_query_engine_tool(index=index)
-
-    configured_tools = ToolFactory.from_env(map_result=True)
-    extractor_tool = configured_tools.get("extract_questions")  # type: ignore
-    filling_tool = configured_tools.get("fill_form")  # type: ignore
-
-    workflow = FormFillingWorkflow(
-        query_engine_tool=query_engine_tool,
-        extractor_tool=extractor_tool,  # type: ignore
-        filling_tool=filling_tool,  # type: ignore
-    )
-
-    return workflow
-
-
-class InputEvent(Event):
-    input: List[ChatMessage]
-    response: bool = False
-
-
-class ExtractMissingCellsEvent(Event):
-    tool_calls: list[ToolSelection]
-
-
-class FindAnswersEvent(Event):
-    tool_calls: list[ToolSelection]
-
-
-class FillEvent(Event):
-    tool_calls: list[ToolSelection]
-
-
-class FormFillingWorkflow(Workflow):
-    """
-    A predefined workflow for filling missing cells in a CSV file.
-    Required tools:
-    - query_engine: A query engine to query for the answers to the questions.
-    - extract_question: Extract missing cells in a CSV file and generate questions to fill them.
-    - answer_question: Query for the answers to the questions.
-
-    Flow:
-    1. Extract missing cells in a CSV file and generate questions to fill them.
-    2. Query for the answers to the questions.
-    3. Fill the missing cells with the answers.
-    """
-
-    _default_system_prompt = """
-    You are a helpful assistant who helps fill missing cells in a CSV file.
-    Only extract missing cells from CSV files.
-    Only use provided data - never make up any information yourself. Fill N/A if an answer is not found.
-    If there is no query engine tool or the gathered information has many N/A values indicating the questions don't match the data, respond with a warning and ask the user to upload a different file or connect to a knowledge base.
-    """
-    stream: bool = True
-
-    def __init__(
-        self,
-        query_engine_tool: Optional[QueryEngineTool],
-        extractor_tool: FunctionTool,
-        filling_tool: FunctionTool,
-        llm: Optional[FunctionCallingLLM] = None,
-        timeout: int = 360,
-        system_prompt: Optional[str] = None,
-    ):
-        super().__init__(timeout=timeout)
-        self.system_prompt = system_prompt or self._default_system_prompt
-        self.query_engine_tool = query_engine_tool
-        self.extractor_tool = extractor_tool
-        self.filling_tool = filling_tool
-        if self.extractor_tool is None or self.filling_tool is None:
-            raise ValueError("Extractor and filling tools are required.")
-        self.tools = [self.extractor_tool, self.filling_tool]
-        if self.query_engine_tool is not None:
-            self.tools.append(self.query_engine_tool)  # type: ignore
-        self.llm: FunctionCallingLLM = llm or Settings.llm
-        if not isinstance(self.llm, FunctionCallingLLM):
-            raise ValueError("FormFillingWorkflow only supports FunctionCallingLLM.")
-        self.memory = ChatMemoryBuffer.from_defaults(llm=self.llm)
-
-    @step()
-    async def start(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:
-            self.memory.put_messages(chat_history)
-
-        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,
-    ) -> ExtractMissingCellsEvent | FillEvent | StopEvent:
-        """
-        Handle an LLM input and decide the next step.
-        """
-        chat_history: list[ChatMessage] = ev.input
-        response = await chat_with_tools(
-            self.llm,
-            self.tools,
-            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())
-        self.memory.put(response.tool_call_message)
-        match response.tool_name():
-            case self.extractor_tool.metadata.name:
-                return ExtractMissingCellsEvent(tool_calls=response.tool_calls)
-            case self.query_engine_tool.metadata.name:
-                return FindAnswersEvent(tool_calls=response.tool_calls)
-            case self.filling_tool.metadata.name:
-                return FillEvent(tool_calls=response.tool_calls)
-            case _:
-                raise ValueError(f"Unknown tool: {response.tool_name()}")
-
-    @step()
-    async def extract_missing_cells(
-        self, ctx: Context, ev: ExtractMissingCellsEvent
-    ) -> InputEvent | FindAnswersEvent:
-        """
-        Extract missing cells in a CSV file and generate questions to fill them.
-        """
-        ctx.write_event_to_stream(
-            AgentRunEvent(
-                name="Extractor",
-                msg="Extracting missing cells",
-            )
-        )
-        # Call the extract questions tool
-        tool_messages = await call_tools(
-            agent_name="Extractor",
-            tools=[self.extractor_tool],
-            ctx=ctx,
-            tool_calls=ev.tool_calls,
-        )
-        self.memory.put_messages(tool_messages)
-        return InputEvent(input=self.memory.get())
-
-    @step()
-    async def find_answers(self, ctx: Context, ev: FindAnswersEvent) -> InputEvent:
-        """
-        Call answer questions tool to query for the answers to the questions.
-        """
-        ctx.write_event_to_stream(
-            AgentRunEvent(
-                name="Researcher",
-                msg="Finding answers for missing cells",
-            )
-        )
-        tool_messages = await call_tools(
-            ctx=ctx,
-            agent_name="Researcher",
-            tools=[self.query_engine_tool],
-            tool_calls=ev.tool_calls,
-        )
-        self.memory.put_messages(tool_messages)
-        return InputEvent(input=self.memory.get())
-
-    @step()
-    async def fill_cells(self, ctx: Context, ev: FillEvent) -> InputEvent:
-        """
-        Call fill cells tool to fill the missing cells with the answers.
-        """
-        ctx.write_event_to_stream(
-            AgentRunEvent(
-                name="Processor",
-                msg="Filling missing cells",
-            )
-        )
-        tool_messages = await call_tools(
-            agent_name="Processor",
-            tools=[self.filling_tool],
-            ctx=ctx,
-            tool_calls=ev.tool_calls,
-        )
-        self.memory.put_messages(tool_messages)
-        return InputEvent(input=self.memory.get())
@@ -1,17 +0,0 @@
-Parameter,2023 Apple (AAPL),2023 Tesla (TSLA)
-Revenue,,
-Net Income,,
-Earnings Per Share (EPS),,
-Debt-to-Equity Ratio,,
-Current Ratio,,
-Gross Margin,,
-Operating Margin,,
-Net Profit Margin,,
-Inventory Turnover,,
-Accounts Receivable Turnover,,
-Capital Expenditure,,
-Research and Development Expense,,
-Market Cap,,
-Price to Earnings Ratio,,
-Dividend Yield,,
-Year-over-Year Growth Rate,,
@@ -1,291 +0,0 @@
-import {
-  HandlerContext,
-  StartEvent,
-  StopEvent,
-  Workflow,
-  WorkflowContext,
-  WorkflowEvent,
-} from "@llamaindex/workflow";
-import { ChatMessage, ChatResponseChunk, Settings } from "llamaindex";
-import {
-  createPublisher,
-  createResearcher,
-  createReviewer,
-  createWriter,
-} from "./agents";
-import {
-  FunctionCallingAgent,
-  FunctionCallingAgentInput,
-} from "./single-agent";
-import { AgentInput, AgentRunEvent } from "./type";
-
-const TIMEOUT = 360 * 1000;
-const MAX_ATTEMPTS = 2;
-
-class ResearchEvent extends WorkflowEvent<{ input: string }> {}
-class WriteEvent extends WorkflowEvent<{
-  input: string;
-  isGood: boolean;
-}> {}
-class ReviewEvent extends WorkflowEvent<{ input: string }> {}
-class PublishEvent extends WorkflowEvent<{ input: string }> {}
-
-type BlogContext = {
-  task: string;
-  attempts: number;
-  result: string;
-};
-
-export const createWorkflow = ({
-  chatHistory,
-  params,
-}: {
-  chatHistory: ChatMessage[];
-  params?: any;
-}) => {
-  const runAgent = async (
-    context: HandlerContext<BlogContext>,
-    agent: FunctionCallingAgent,
-    input: FunctionCallingAgentInput,
-  ) => {
-    const agentContext = agent.run(input, {
-      streaming: input.streaming ?? false,
-    });
-    for await (const event of agentContext) {
-      if (event instanceof AgentRunEvent) {
-        context.sendEvent(event);
-      }
-      if (event instanceof StopEvent) {
-        return event;
-      }
-    }
-    return null;
-  };
-
-  const start = async (
-    context: HandlerContext<BlogContext>,
-    ev: StartEvent<AgentInput>,
-  ) => {
-    const chatHistoryStr = chatHistory
-      .map((msg) => `${msg.role}: ${msg.content}`)
-      .join("\n");
-
-    // Decision-making process
-    const decision = await decideWorkflow(
-      ev.data.message.toString(),
-      chatHistoryStr,
-    );
-
-    if (decision !== "publish") {
-      return new ResearchEvent({
-        input: `Research for this task: ${JSON.stringify(context.data.task)}`,
-      });
-    } else {
-      return new PublishEvent({
-        input: `Publish content based on the chat history\n${chatHistoryStr}\n\n and task: ${context.data.task}`,
-      });
-    }
-  };
-
-  const decideWorkflow = async (task: string, chatHistoryStr: string) => {
-    const llm = Settings.llm;
-
-    const prompt = `You are an expert in decision-making, helping people write and publish blog posts.
-If the user is asking for a file or to publish content, respond with 'publish'.
-If the user requests to write or update a blog post, respond with 'not_publish'.
-
-Here is the chat history:
-${chatHistoryStr}
-
-The current user request is:
-${task}
-
-Given the chat history and the new user request, decide whether to publish based on existing information.
-Decision (respond with either 'not_publish' or 'publish'):`;
-
-    const output = await llm.complete({ prompt: prompt });
-    const decision = output.text.trim().toLowerCase();
-    return decision === "publish" ? "publish" : "research";
-  };
-
-  const research = async (
-    context: HandlerContext<BlogContext>,
-    ev: ResearchEvent,
-  ) => {
-    const researcher = await createResearcher(chatHistory);
-    const researchRes = await runAgent(context, researcher, {
-      displayName: "Researcher",
-      message: ev.data.input,
-    });
-    const researchResult = researchRes?.data;
-
-    return new WriteEvent({
-      input: `Write a blog post given this task: ${JSON.stringify(
-        context.data.task,
-      )} using this research content: ${researchResult}`,
-      isGood: false,
-    });
-  };
-
-  const write = async (
-    context: HandlerContext<BlogContext>,
-    ev: WriteEvent,
-  ) => {
-    const writer = createWriter(chatHistory);
-    context.data.attempts = context.data.attempts + 1;
-    const tooManyAttempts = context.data.attempts > MAX_ATTEMPTS;
-    if (tooManyAttempts) {
-      context.sendEvent(
-        new AgentRunEvent({
-          agent: "writer",
-          text: `Too many attempts (${MAX_ATTEMPTS}) to write the blog post. Proceeding with the current version.`,
-          type: "text",
-        }),
-      );
-    }
-
-    if (ev.data.isGood || tooManyAttempts) {
-      // the blog post is good or too many attempts
-      // stream the final content
-      const result = await runAgent(context, writer, {
-        message: `Based on the reviewer's feedback, refine the post and return only the final version of the post. Here's the current version: ${ev.data.input}`,
-        displayName: "Writer",
-        streaming: true,
-      });
-      return result as unknown as StopEvent<AsyncGenerator<ChatResponseChunk>>;
-    }
-
-    const writeRes = await runAgent(context, writer, {
-      message: ev.data.input,
-      displayName: "Writer",
-      streaming: false,
-    });
-    const writeResult = writeRes?.data;
-    context.data.result = writeResult; // store the last result
-
-    return new ReviewEvent({ input: writeResult });
-  };
-
-  const review = async (
-    context: HandlerContext<BlogContext>,
-    ev: ReviewEvent,
-  ) => {
-    const reviewer = createReviewer(chatHistory);
-    const reviewResult = (await runAgent(context, reviewer, {
-      message: ev.data.input,
-      displayName: "Reviewer",
-      streaming: false,
-    })) as unknown as StopEvent<string>;
-    const reviewResultStr = reviewResult.data;
-    const oldContent = context.data.result;
-    const postIsGood = reviewResultStr.toLowerCase().includes("post is good");
-    context.sendEvent(
-      new AgentRunEvent({
-        agent: "reviewer",
-        text: `The post is ${postIsGood ? "" : "not "}good enough for publishing. Sending back to the writer${
-          postIsGood ? " for publication." : "."
-        }`,
-        type: "text",
-      }),
-    );
-    if (postIsGood) {
-      return new WriteEvent({
-        input: "",
-        isGood: true,
-      });
-    }
-
-    return new WriteEvent({
-      input: `Improve the writing of a given blog post by using a given review.
-            Blog post:
-            \`\`\`
-            ${oldContent}
-            \`\`\`
-
-            Review:
-            \`\`\`
-            ${reviewResult}
-            \`\`\``,
-      isGood: false,
-    });
-  };
-
-  const publish = async (
-    context: HandlerContext<BlogContext>,
-    ev: PublishEvent,
-  ) => {
-    const publisher = await createPublisher(chatHistory);
-
-    const publishResult = await runAgent(context, publisher, {
-      message: `${ev.data.input}`,
-      displayName: "Publisher",
-      streaming: true,
-    });
-    return publishResult as unknown as StopEvent<
-      AsyncGenerator<ChatResponseChunk>
-    >;
-  };
-
-  const workflow: Workflow<
-    BlogContext,
-    AgentInput,
-    string | AsyncGenerator<boolean | ChatResponseChunk>
-  > = new Workflow();
-
-  workflow.addStep(
-    {
-      inputs: [StartEvent<AgentInput>],
-      outputs: [ResearchEvent, PublishEvent],
-    },
-    start,
-  );
-
-  workflow.addStep(
-    {
-      inputs: [ResearchEvent],
-      outputs: [WriteEvent],
-    },
-    research,
-  );
-
-  workflow.addStep(
-    {
-      inputs: [WriteEvent],
-      outputs: [ReviewEvent, StopEvent<AsyncGenerator<ChatResponseChunk>>],
-    },
-    write,
-  );
-
-  workflow.addStep(
-    {
-      inputs: [ReviewEvent],
-      outputs: [WriteEvent],
-    },
-    review,
-  );
-
-  workflow.addStep(
-    {
-      inputs: [PublishEvent],
-      outputs: [StopEvent],
-    },
-    publish,
-  );
-
-  // Overload run method to initialize the context
-  workflow.run = function (
-    input: AgentInput,
-  ): WorkflowContext<
-    AgentInput,
-    string | AsyncGenerator<boolean | ChatResponseChunk>,
-    BlogContext
-  > {
-    return Workflow.prototype.run.call(workflow, new StartEvent(input), {
-      task: input.message.toString(),
-      attempts: 0,
-      result: "",
-    });
-  };
-
-  return workflow;
-};
@@ -1,47 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) project using [Next.js](https://nextjs.org/) 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 the `OPENAI_API_KEY` set.
-
-Second, generate the embeddings of the 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.
-
-## Use Case: Filling Financial CSV Template
-
-You can start by sending an request on the chat UI to create a report comparing the finances of Apple and Tesla.
-Or you can test the `/api/chat` endpoint with the following curl request:
-
-```
-curl --location 'localhost:3000/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 (Python features).
- [LlamaIndexTS Documentation](https://ts.llamaindex.ai/docs/llamaindex) - learn about LlamaIndex (Typescript features).
- [Workflows Introduction](https://ts.llamaindex.ai/docs/llamaindex/guide/workflow) - learn about LlamaIndexTS workflows.
-
-You can check out [the LlamaIndexTS GitHub repository](https://github.com/run-llama/LlamaIndexTS) - your feedback and contributions are welcome!
@@ -1,28 +0,0 @@
-import { ChatMessage, ToolCallLLM } from "llamaindex";
-import { getTool } from "../engine/tools";
-import { FinancialReportWorkflow } from "./fin-report";
-import { getQueryEngineTool } from "./tools";
-
-const TIMEOUT = 360 * 1000;
-
-export async function createWorkflow(options: {
-  chatHistory: ChatMessage[];
-  llm?: ToolCallLLM;
-}) {
-  const queryEngineTool = await getQueryEngineTool();
-  const codeInterpreterTool = await getTool("interpreter");
-  const documentGeneratorTool = await getTool("document_generator");
-
-  if (!queryEngineTool || !codeInterpreterTool || !documentGeneratorTool) {
-    throw new Error("One or more required tools are not defined");
-  }
-
-  return new FinancialReportWorkflow({
-    chatHistory: options.chatHistory,
-    queryEngineTool,
-    codeInterpreterTool,
-    documentGeneratorTool,
-    llm: options.llm,
-    timeout: TIMEOUT,
-  });
-}
@@ -1,320 +0,0 @@
-import {
-  HandlerContext,
-  StartEvent,
-  StopEvent,
-  Workflow,
-  WorkflowEvent,
-} from "@llamaindex/workflow";
-import {
-  BaseToolWithCall,
-  ChatMemoryBuffer,
-  ChatMessage,
-  ChatResponseChunk,
-  Settings,
-  ToolCall,
-  ToolCallLLM,
-} from "llamaindex";
-import { callTools, chatWithTools } from "./tools";
-import { AgentInput, AgentRunEvent } from "./type";
-
-// Create a custom event type
-class InputEvent extends WorkflowEvent<{ input: ChatMessage[] }> {}
-
-class ResearchEvent extends WorkflowEvent<{
-  toolCalls: ToolCall[];
-}> {}
-
-class AnalyzeEvent extends WorkflowEvent<{
-  input: ChatMessage | ToolCall[];
-}> {}
-
-class ReportGenerationEvent extends 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.
-`;
-
-export class FinancialReportWorkflow extends Workflow<
-  null,
-  AgentInput,
-  ChatResponseChunk
-> {
-  llm: ToolCallLLM;
-  memory: ChatMemoryBuffer;
-  queryEngineTool: BaseToolWithCall;
-  codeInterpreterTool: BaseToolWithCall;
-  documentGeneratorTool: BaseToolWithCall;
-  systemPrompt?: string;
-
-  constructor(options: {
-    llm?: ToolCallLLM;
-    chatHistory: ChatMessage[];
-    queryEngineTool: BaseToolWithCall;
-    codeInterpreterTool: BaseToolWithCall;
-    documentGeneratorTool: BaseToolWithCall;
-    systemPrompt?: string;
-    verbose?: boolean;
-    timeout?: number;
-  }) {
-    super({
-      verbose: options?.verbose ?? false,
-      timeout: options?.timeout ?? 360,
-    });
-
-    this.llm = options.llm ?? (Settings.llm as ToolCallLLM);
-    if (!(this.llm instanceof ToolCallLLM)) {
-      throw new Error("LLM is not a ToolCallLLM");
-    }
-    this.systemPrompt = options.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
-    this.queryEngineTool = options.queryEngineTool;
-    this.codeInterpreterTool = options.codeInterpreterTool;
-
-    this.documentGeneratorTool = options.documentGeneratorTool;
-    this.memory = new ChatMemoryBuffer({
-      llm: this.llm,
-      chatHistory: options.chatHistory,
-    });
-
-    // Add steps
-    this.addStep(
-      {
-        inputs: [StartEvent<AgentInput>],
-        outputs: [InputEvent],
-      },
-      this.prepareChatHistory,
-    );
-
-    this.addStep(
-      {
-        inputs: [InputEvent],
-        outputs: [
-          InputEvent,
-          ResearchEvent,
-          AnalyzeEvent,
-          ReportGenerationEvent,
-          StopEvent,
-        ],
-      },
-      this.handleLLMInput,
-    );
-
-    this.addStep(
-      {
-        inputs: [ResearchEvent],
-        outputs: [AnalyzeEvent],
-      },
-      this.handleResearch,
-    );
-
-    this.addStep(
-      {
-        inputs: [AnalyzeEvent],
-        outputs: [InputEvent],
-      },
-      this.handleAnalyze,
-    );
-
-    this.addStep(
-      {
-        inputs: [ReportGenerationEvent],
-        outputs: [InputEvent],
-      },
-      this.handleReportGeneration,
-    );
-  }
-
-  prepareChatHistory = async (
-    ctx: HandlerContext<null>,
-    ev: StartEvent<AgentInput>,
-  ): Promise<InputEvent> => {
-    const { message } = ev.data;
-
-    if (this.systemPrompt) {
-      this.memory.put({ role: "system", content: this.systemPrompt });
-    }
-    this.memory.put({ role: "user", content: message });
-
-    return new InputEvent({ input: this.memory.getMessages() });
-  };
-
-  handleLLMInput = async (
-    ctx: HandlerContext<null>,
-    ev: InputEvent,
-  ): Promise<
-    | InputEvent
-    | ResearchEvent
-    | AnalyzeEvent
-    | ReportGenerationEvent
-    | StopEvent
-  > => {
-    const chatHistory = ev.data.input;
-
-    const tools = [
-      this.codeInterpreterTool,
-      this.documentGeneratorTool,
-      this.queryEngineTool,
-    ];
-
-    const toolCallResponse = await chatWithTools(this.llm, tools, chatHistory);
-
-    if (!toolCallResponse.hasToolCall()) {
-      return new StopEvent(toolCallResponse.responseGenerator);
-    }
-
-    if (toolCallResponse.hasMultipleTools()) {
-      this.memory.put({
-        role: "assistant",
-        content:
-          "Calling different tools is not allowed. Please only use multiple calls of the same tool.",
-      });
-      return new InputEvent({ input: this.memory.getMessages() });
-    }
-
-    // Put the LLM tool call message into the memory
-    // And trigger the next step according to the tool call
-    if (toolCallResponse.toolCallMessage) {
-      this.memory.put(toolCallResponse.toolCallMessage);
-    }
-    const toolName = toolCallResponse.getToolNames()[0];
-    switch (toolName) {
-      case this.codeInterpreterTool.metadata.name:
-        return new AnalyzeEvent({
-          input: toolCallResponse.toolCalls,
-        });
-      case this.documentGeneratorTool.metadata.name:
-        return new ReportGenerationEvent({
-          toolCalls: toolCallResponse.toolCalls,
-        });
-      default:
-        if (this.queryEngineTool.metadata.name === toolName) {
-          return new ResearchEvent({
-            toolCalls: toolCallResponse.toolCalls,
-          });
-        }
-        throw new Error(`Unknown tool: ${toolName}`);
-    }
-  };
-
-  handleResearch = async (
-    ctx: HandlerContext<null>,
-    ev: ResearchEvent,
-  ): Promise<AnalyzeEvent> => {
-    ctx.sendEvent(
-      new AgentRunEvent({
-        agent: "Researcher",
-        text: "Researching data",
-        type: "text",
-      }),
-    );
-
-    const { toolCalls } = ev.data;
-
-    const toolMsgs = await callTools({
-      tools: [this.queryEngineTool],
-      toolCalls,
-      ctx,
-      agentName: "Researcher",
-    });
-    for (const toolMsg of toolMsgs) {
-      this.memory.put(toolMsg);
-    }
-    return new AnalyzeEvent({
-      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
-   */
-  handleAnalyze = async (
-    ctx: HandlerContext<null>,
-    ev: AnalyzeEvent,
-  ): Promise<InputEvent> => {
-    ctx.sendEvent(
-      new AgentRunEvent({
-        agent: "Analyst",
-        text: `Starting analysis`,
-        type: "text",
-      }),
-    );
-    // Request by workflow LLM, input is a list of tool calls
-    let toolCalls: ToolCall[] = [];
-    if (Array.isArray(ev.data.input)) {
-      toolCalls = ev.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 newChatHistory = [
-        ...this.memory.getMessages(),
-        { role: "system", content: analysisPrompt },
-        ev.data.input,
-      ];
-      const toolCallResponse = await chatWithTools(
-        this.llm,
-        [this.codeInterpreterTool],
-        newChatHistory as ChatMessage[],
-      );
-
-      if (!toolCallResponse.hasToolCall()) {
-        this.memory.put(await toolCallResponse.asFullResponse());
-        return new InputEvent({
-          input: this.memory.getMessages(),
-        });
-      } else {
-        this.memory.put(toolCallResponse.toolCallMessage);
-        toolCalls = toolCallResponse.toolCalls;
-      }
-    }
-
-    // Call the tools
-    const toolMsgs = await callTools({
-      tools: [this.codeInterpreterTool],
-      toolCalls,
-      ctx,
-      agentName: "Analyst",
-    });
-    for (const toolMsg of toolMsgs) {
-      this.memory.put(toolMsg);
-    }
-
-    return new InputEvent({
-      input: this.memory.getMessages(),
-    });
-  };
-
-  handleReportGeneration = async (
-    ctx: HandlerContext<null>,
-    ev: ReportGenerationEvent,
-  ): Promise<InputEvent> => {
-    const { toolCalls } = ev.data;
-
-    const toolMsgs = await callTools({
-      tools: [this.documentGeneratorTool],
-      toolCalls,
-      ctx,
-      agentName: "Reporter",
-    });
-    for (const toolMsg of toolMsgs) {
-      this.memory.put(toolMsg);
-    }
-    return new InputEvent({ input: this.memory.getMessages() });
-  };
-}
@@ -1,37 +0,0 @@
-This is a [LlamaIndex](https://www.llamaindex.ai/) project using [Next.js](https://nextjs.org/) 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 the `OPENAI_API_KEY` set.
-
-Second, run the development server:
-
-```
-npm run dev
-```
-
-Open [http://localhost:3000](http://localhost:3000) with your browser to see the chat UI.
-
-## Use Case: Filling Financial CSV Template
-
-1. Upload the Apple and Tesla financial reports from the [data](./data) directory. Just send an empty message.
-2. Upload the CSV file [sec_10k_template.csv](./sec_10k_template.csv) and send the message "Fill the missing cells in the CSV file".
-
-The agent will fill the missing cells by retrieving the information from the uploaded financial reports and return a new CSV file with the filled cells.
-
-## 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/guide/workflow) - learn about LlamaIndexTS workflows.
-
-You can check out [the LlamaIndexTS GitHub repository](https://github.com/run-llama/LlamaIndexTS) - your feedback and contributions are welcome!
@@ -1,17 +0,0 @@
-Parameter,2023 Apple (AAPL),2023 Tesla (TSLA)
-Revenue,,
-Net Income,,
-Earnings Per Share (EPS),,
-Debt-to-Equity Ratio,,
-Current Ratio,,
-Gross Margin,,
-Operating Margin,,
-Net Profit Margin,,
-Inventory Turnover,,
-Accounts Receivable Turnover,,
-Capital Expenditure,,
-Research and Development Expense,,
-Market Cap,,
-Price to Earnings Ratio,,
-Dividend Yield,,
-Year-over-Year Growth Rate,,
@@ -1,27 +0,0 @@
-import { ChatMessage, ToolCallLLM } from "llamaindex";
-import { getTool } from "../engine/tools";
-import { FormFillingWorkflow } from "./form-filling";
-import { getQueryEngineTool } from "./tools";
-
-const TIMEOUT = 360 * 1000;
-
-export async function createWorkflow(options: {
-  chatHistory: ChatMessage[];
-  llm?: ToolCallLLM;
-}) {
-  const extractorTool = await getTool("extract_missing_cells");
-  const fillMissingCellsTool = await getTool("fill_missing_cells");
-
-  if (!extractorTool || !fillMissingCellsTool) {
-    throw new Error("One or more required tools are not defined");
-  }
-
-  return new FormFillingWorkflow({
-    chatHistory: options.chatHistory,
-    queryEngineTool: (await getQueryEngineTool()) || undefined,
-    extractorTool,
-    fillMissingCellsTool,
-    llm: options.llm,
-    timeout: TIMEOUT,
-  });
-}
@@ -1,275 +0,0 @@
-import {
-  HandlerContext,
-  StartEvent,
-  StopEvent,
-  Workflow,
-  WorkflowEvent,
-} from "@llamaindex/workflow";
-import {
-  BaseToolWithCall,
-  ChatMemoryBuffer,
-  ChatMessage,
-  ChatResponseChunk,
-  Settings,
-  ToolCall,
-  ToolCallLLM,
-} from "llamaindex";
-import { callTools, chatWithTools } from "./tools";
-import { AgentInput, AgentRunEvent } from "./type";
-
-// Create a custom event type
-class InputEvent extends WorkflowEvent<{ input: ChatMessage[] }> {}
-
-class ExtractMissingCellsEvent extends WorkflowEvent<{
-  toolCalls: ToolCall[];
-}> {}
-
-class FindAnswersEvent extends WorkflowEvent<{
-  toolCalls: ToolCall[];
-}> {}
-
-class FillMissingCellsEvent extends WorkflowEvent<{
-  toolCalls: ToolCall[];
-}> {}
-
-const DEFAULT_SYSTEM_PROMPT = `
-You are a helpful assistant who helps fill missing cells in a CSV file.
-Only use the information from the retriever tool - don't make up any information yourself. Fill N/A if an answer is not found.
-If there is no retriever tool or the gathered information has many N/A values indicating the questions don't match the data, respond with a warning and ask the user to upload a different file or connect to a knowledge base.
-You can make multiple tool calls at once but only call with the same tool.
-Only use the local file path for the tools.
-`;
-
-export class FormFillingWorkflow extends Workflow<
-  null,
-  AgentInput,
-  ChatResponseChunk
-> {
-  llm: ToolCallLLM;
-  memory: ChatMemoryBuffer;
-  extractorTool: BaseToolWithCall;
-  queryEngineTool?: BaseToolWithCall;
-  fillMissingCellsTool: BaseToolWithCall;
-  systemPrompt?: string;
-
-  constructor(options: {
-    llm?: ToolCallLLM;
-    chatHistory: ChatMessage[];
-    extractorTool: BaseToolWithCall;
-    queryEngineTool?: BaseToolWithCall;
-    fillMissingCellsTool: BaseToolWithCall;
-    systemPrompt?: string;
-    verbose?: boolean;
-    timeout?: number;
-  }) {
-    super({
-      verbose: options?.verbose ?? false,
-      timeout: options?.timeout ?? 360,
-    });
-
-    this.llm = options.llm ?? (Settings.llm as ToolCallLLM);
-    if (!(this.llm instanceof ToolCallLLM)) {
-      throw new Error("LLM is not a ToolCallLLM");
-    }
-    this.systemPrompt = options.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
-    this.extractorTool = options.extractorTool;
-    this.queryEngineTool = options.queryEngineTool;
-    this.fillMissingCellsTool = options.fillMissingCellsTool;
-
-    this.memory = new ChatMemoryBuffer({
-      llm: this.llm,
-      chatHistory: options.chatHistory,
-    });
-
-    // Add steps
-    this.addStep(
-      {
-        inputs: [StartEvent<AgentInput>],
-        outputs: [InputEvent],
-      },
-      this.prepareChatHistory,
-    );
-
-    this.addStep(
-      {
-        inputs: [InputEvent],
-        outputs: [
-          InputEvent,
-          ExtractMissingCellsEvent,
-          FindAnswersEvent,
-          FillMissingCellsEvent,
-          StopEvent,
-        ],
-      },
-      this.handleLLMInput,
-    );
-
-    this.addStep(
-      {
-        inputs: [ExtractMissingCellsEvent],
-        outputs: [InputEvent],
-      },
-      this.handleExtractMissingCells,
-    );
-
-    this.addStep(
-      {
-        inputs: [FindAnswersEvent],
-        outputs: [InputEvent],
-      },
-      this.handleFindAnswers,
-    );
-
-    this.addStep(
-      {
-        inputs: [FillMissingCellsEvent],
-        outputs: [InputEvent],
-      },
-      this.handleFillMissingCells,
-    );
-  }
-
-  prepareChatHistory = async (
-    ctx: HandlerContext<null>,
-    ev: StartEvent<AgentInput>,
-  ): Promise<InputEvent> => {
-    const { message } = ev.data;
-
-    if (this.systemPrompt) {
-      this.memory.put({ role: "system", content: this.systemPrompt });
-    }
-    this.memory.put({ role: "user", content: message });
-
-    return new InputEvent({ input: this.memory.getMessages() });
-  };
-
-  handleLLMInput = async (
-    ctx: HandlerContext<null>,
-    ev: InputEvent,
-  ): Promise<
-    | InputEvent
-    | ExtractMissingCellsEvent
-    | FindAnswersEvent
-    | FillMissingCellsEvent
-    | StopEvent
-  > => {
-    const chatHistory = ev.data.input;
-
-    const tools = [this.extractorTool, this.fillMissingCellsTool];
-    if (this.queryEngineTool) {
-      tools.push(this.queryEngineTool);
-    }
-
-    const toolCallResponse = await chatWithTools(this.llm, tools, chatHistory);
-
-    if (!toolCallResponse.hasToolCall()) {
-      return new StopEvent(toolCallResponse.responseGenerator);
-    }
-
-    if (toolCallResponse.hasMultipleTools()) {
-      this.memory.put({
-        role: "assistant",
-        content:
-          "Calling different tools is not allowed. Please only use multiple calls of the same tool.",
-      });
-      return new InputEvent({ input: this.memory.getMessages() });
-    }
-
-    // Put the LLM tool call message into the memory
-    // And trigger the next step according to the tool call
-    if (toolCallResponse.toolCallMessage) {
-      this.memory.put(toolCallResponse.toolCallMessage);
-    }
-    const toolName = toolCallResponse.getToolNames()[0];
-    switch (toolName) {
-      case this.extractorTool.metadata.name:
-        return new ExtractMissingCellsEvent({
-          toolCalls: toolCallResponse.toolCalls,
-        });
-      case this.fillMissingCellsTool.metadata.name:
-        return new FillMissingCellsEvent({
-          toolCalls: toolCallResponse.toolCalls,
-        });
-      default:
-        if (
-          this.queryEngineTool &&
-          this.queryEngineTool.metadata.name === toolName
-        ) {
-          return new FindAnswersEvent({
-            toolCalls: toolCallResponse.toolCalls,
-          });
-        }
-        throw new Error(`Unknown tool: ${toolName}`);
-    }
-  };
-
-  handleExtractMissingCells = async (
-    ctx: HandlerContext<null>,
-    ev: ExtractMissingCellsEvent,
-  ): Promise<InputEvent> => {
-    ctx.sendEvent(
-      new AgentRunEvent({
-        agent: "CSVExtractor",
-        text: "Extracting missing cells",
-        type: "text",
-      }),
-    );
-    const { toolCalls } = ev.data;
-    const toolMsgs = await callTools({
-      tools: [this.extractorTool],
-      toolCalls,
-      ctx,
-      agentName: "CSVExtractor",
-    });
-    for (const toolMsg of toolMsgs) {
-      this.memory.put(toolMsg);
-    }
-    return new InputEvent({ input: this.memory.getMessages() });
-  };
-
-  handleFindAnswers = async (
-    ctx: HandlerContext<null>,
-    ev: FindAnswersEvent,
-  ): Promise<InputEvent> => {
-    const { toolCalls } = ev.data;
-    if (!this.queryEngineTool) {
-      throw new Error("Query engine tool is not available");
-    }
-    ctx.sendEvent(
-      new AgentRunEvent({
-        agent: "Researcher",
-        text: "Finding answers",
-        type: "text",
-      }),
-    );
-    const toolMsgs = await callTools({
-      tools: [this.queryEngineTool],
-      toolCalls,
-      ctx,
-      agentName: "Researcher",
-    });
-
-    for (const toolMsg of toolMsgs) {
-      this.memory.put(toolMsg);
-    }
-    return new InputEvent({ input: this.memory.getMessages() });
-  };
-
-  handleFillMissingCells = async (
-    ctx: HandlerContext<null>,
-    ev: FillMissingCellsEvent,
-  ): Promise<InputEvent> => {
-    const { toolCalls } = ev.data;
-
-    const toolMsgs = await callTools({
-      tools: [this.fillMissingCellsTool],
-      toolCalls,
-      ctx,
-      agentName: "Processor",
-    });
-    for (const toolMsg of toolMsgs) {
-      this.memory.put(toolMsg);
-    }
-    return new InputEvent({ input: this.memory.getMessages() });
-  };
-}
@@ -1,224 +0,0 @@
-import logging
-import os
-import uuid
-from textwrap import dedent
-from typing import Optional
-
-import pandas as pd
-from app.services.file import FileService
-from llama_index.core import Settings
-from llama_index.core.prompts import PromptTemplate
-from llama_index.core.tools import FunctionTool
-from pydantic import BaseModel, Field
-
-logger = logging.getLogger(__name__)
-
-
-class MissingCell(BaseModel):
-    """
-    A missing cell in a table.
-    """
-
-    row_index: int = Field(description="The index of the row of the missing cell")
-    column_index: int = Field(description="The index of the column of the missing cell")
-    question_to_answer: str = Field(
-        description="The question to answer to fill the missing cell"
-    )
-
-
-class MissingCells(BaseModel):
-    """
-    A list of missing cells.
-    """
-
-    missing_cells: list[MissingCell] = Field(description="The missing cells")
-
-
-class CellValue(BaseModel):
-    row_index: int = Field(description="The row index of the cell")
-    column_index: int = Field(description="The column index of the cell")
-    value: str = Field(
-        description="The value of the cell. Should be a concise value (numerical value or specific value)"
-    )
-
-
-class FormFillingTool:
-    """
-    Fill out missing cells in a CSV file using information from the knowledge base.
-    """
-
-    save_dir: str = os.path.join("output", "tools")
-
-    # Default prompt for extracting questions
-    # Replace the default prompt with a custom prompt by setting the EXTRACT_QUESTIONS_PROMPT environment variable.
-    _default_extract_questions_prompt = dedent(
-        """
-        You are a data analyst. You are given a table with missing cells.
-        Your task is to identify the missing cells and the questions needed to fill them.
-        IMPORTANT: Column indices should be 0-based, where the first data column is index 1 
-        (index 0 is typically the row names/index column).
-
-        # Instructions:
-        - Understand the entire content of the table and the topics of the table.
-        - Identify the missing cells and the meaning of the data in the cells.
-        - For each missing cell, provide the row index and the correct column index (remember: first data column is 1).
-        - For each missing cell, provide the question needed to fill the cell (it's important to provide the question that is relevant to the topic of the table).
-        - Since the cell's value should be concise, the question should request a numerical answer or a specific value.
-
-        # Example:
-        # |    | Name | Age | City |
-        # |----|------|-----|------|
-        # | 0  | John |     | Paris|
-        # | 1  | Mary |     |      |
-        # | 2  |      | 30  |      |
-        #
-        # Your thoughts:
-        # - The table is about people's names, ages, and cities.
-        # - Row: 1, Column: 1 (Age column), Question: "How old is Mary? Please provide only the numerical answer."
-        # - Row: 1, Column: 2 (City column), Question: "In which city does Mary live? Please provide only the city name."
-        
-
-        Please provide your answer in the requested format.
-        # Here is your task:
-
-        - Table content:
-        {table_content}
-
-        - Your answer:
-        """
-    )
-
-    def extract_questions(
-        self,
-        file_path: Optional[str] = None,
-        file_content: Optional[str] = None,
-    ) -> dict:
-        """
-        Use this tool to extract missing cells in a CSV file and generate questions to fill them.
-        Pass either the path to the CSV file or the content of the CSV file.
-
-        Args:
-            file_path (Optional[str]): The local file path to the CSV file to extract missing cells from (Don't pass a sandbox path).
-            file_content (Optional[str]): The content of the CSV file to extract missing cells from.
-
-        Returns:
-            dict: A dictionary containing the missing cells and their corresponding questions.
-        """
-        extract_questions_prompt = os.getenv(
-            "EXTRACT_QUESTIONS_PROMPT", self._default_extract_questions_prompt
-        )
-        if file_path is None and file_content is None:
-            raise ValueError("Either `file_path` or `file_content` must be provided")
-
-        table_content = None
-
-        if file_path:
-            file_name, file_extension = self._get_file_name_and_extension(
-                file_path, file_content
-            )
-
-            try:
-                df = pd.read_csv(file_path)
-            except FileNotFoundError as e:
-                return {
-                    "error": str(e),
-                    "message": "Please check and update the file path and ensure it's a local path - not a sandbox path.",
-                }
-
-            table_content = df.to_markdown()
-            if table_content is None:
-                raise ValueError("Could not convert the table to markdown")
-        if file_content:
-            table_content = file_content
-
-        if table_content is None:
-            raise ValueError("Table content not found")
-
-        response: MissingCells = Settings.llm.structured_predict(
-            output_cls=MissingCells,
-            prompt=PromptTemplate(extract_questions_prompt),
-            table_content=table_content,
-        )
-        return response.model_dump()
-
-    def fill_form(
-        self,
-        cell_values: list[CellValue],
-        file_path: Optional[str] = None,
-        file_content: Optional[str] = None,
-    ) -> dict:
-        """
-        Use this tool to fill cell values into a CSV file.
-        Requires cell values to be used for filling out, as well as either the path to the CSV file or the content of the CSV file.
-
-        Args:
-            cell_values (list[CellValue]): The cell values used to fill out the CSV file (call `extract_questions` and query engine to construct the cell values).
-            file_path (Optional[str]): The local file path to the CSV file that should be filled out (not as sandbox path).
-            file_content (Optional[str]): The content of the CSV file that should be filled out.
-
-        Returns:
-            dict: A dictionary containing the content and metadata of the filled-out file.
-        """
-        file_name, file_extension = self._get_file_name_and_extension(
-            file_path, file_content
-        )
-        df = pd.read_csv(file_path)
-
-        # Fill the dataframe with the cell values
-        filled_df = df.copy()
-        for cell_value in cell_values:
-            if not isinstance(cell_value, CellValue):
-                cell_value = CellValue(**cell_value)
-            filled_df.iloc[cell_value.row_index, cell_value.column_index] = (
-                cell_value.value
-            )
-
-        # Save the filled table to a new CSV file
-        csv_content: str = filled_df.to_csv(index=False)
-        file_metadata = FileService.save_file(
-            content=csv_content,
-            file_name=f"{file_name}_filled.csv",
-            save_dir=self.save_dir,
-        )
-
-        new_content: str = filled_df.to_markdown()
-        result = {
-            "filled_content": new_content,
-            "filled_file": file_metadata,
-        }
-        return result
-
-    def _get_file_name_and_extension(
-        self, file_path: Optional[str], file_content: Optional[str]
-    ) -> tuple[str, str]:
-        if file_path is None and file_content is None:
-            raise ValueError("Either `file_path` or `file_content` must be provided")
-
-        if file_path is None:
-            file_name = str(uuid.uuid4())
-            file_extension = ".csv"
-        else:
-            file_name, file_extension = os.path.splitext(file_path)
-            if file_extension != ".csv":
-                raise ValueError("Form filling is only supported for CSV files")
-
-        return file_name, file_extension
-
-    def _save_output(self, file_name: str, output: str) -> dict:
-        """
-        Save the output to a file.
-        """
-        file_metadata = FileService.save_file(
-            content=output,
-            file_name=file_name,
-            save_dir=self.save_dir,
-        )
-        return file_metadata.model_dump()
-
-
-def get_tools(**kwargs):
-    tool = FormFillingTool()
-    return [
-        FunctionTool.from_defaults(tool.extract_questions),
-        FunctionTool.from_defaults(tool.fill_form),
-    ]
@@ -1,202 +0,0 @@
-import base64
-import logging
-import os
-import uuid
-from typing import List, Optional
-
-from app.services.file import DocumentFile, FileService
-from e2b_code_interpreter import Sandbox
-from e2b_code_interpreter.models import Logs
-from llama_index.core.tools import FunctionTool
-from pydantic import BaseModel
-
-logger = logging.getLogger("uvicorn")
-
-
-class InterpreterExtraResult(BaseModel):
-    type: str
-    content: Optional[str] = None
-    filename: Optional[str] = None
-    url: Optional[str] = None
-
-
-class E2BToolOutput(BaseModel):
-    is_error: bool
-    logs: Logs
-    error_message: Optional[str] = None
-    results: List[InterpreterExtraResult] = []
-    retry_count: int = 0
-
-
-class E2BCodeInterpreter:
-    output_dir = "output/tools"
-    uploaded_files_dir = "output/uploaded"
-
-    def __init__(self, api_key: Optional[str] = None):
-        if api_key is None:
-            api_key = os.getenv("E2B_API_KEY")
-        filesever_url_prefix = os.getenv("FILESERVER_URL_PREFIX")
-        if not api_key:
-            raise ValueError(
-                "E2B_API_KEY key is required to run code interpreter. Get it here: https://e2b.dev/docs/getting-started/api-key"
-            )
-        if not filesever_url_prefix:
-            raise ValueError(
-                "FILESERVER_URL_PREFIX is required to display file output from sandbox"
-            )
-
-        self.filesever_url_prefix = filesever_url_prefix
-        self.interpreter = None
-        self.api_key = api_key
-
-    def __del__(self):
-        """
-        Kill the interpreter when the tool is no longer in use
-        """
-        if self.interpreter is not None:
-            self.interpreter.kill()
-
-    def _init_interpreter(self, sandbox_files: List[str] = []):
-        """
-        Lazily initialize the interpreter.
-        """
-        logger.info(f"Initializing interpreter with {len(sandbox_files)} files")
-        self.interpreter = Sandbox(api_key=self.api_key)
-        if len(sandbox_files) > 0:
-            for file_path in sandbox_files:
-                file_name = os.path.basename(file_path)
-                local_file_path = os.path.join(self.uploaded_files_dir, file_name)
-                with open(local_file_path, "rb") as f:
-                    content = f.read()
-                    if self.interpreter and self.interpreter.files:
-                        self.interpreter.files.write(file_path, content)
-            logger.info(f"Uploaded {len(sandbox_files)} files to sandbox")
-
-    def _save_to_disk(self, base64_data: str, ext: str) -> DocumentFile:
-        buffer = base64.b64decode(base64_data)
-
-        # Output from e2b doesn't have a name. Create a random name for it.
-        filename = f"e2b_file_{uuid.uuid4()}.{ext}"
-
-        document_file = FileService.save_file(
-            buffer, file_name=filename, save_dir=self.output_dir
-        )
-
-        return document_file
-
-    def _parse_result(self, result) -> List[InterpreterExtraResult]:
-        """
-        The result could include multiple formats (e.g. png, svg, etc.) but encoded in base64
-        We save each result to disk and return saved file metadata (extension, filename, url)
-        """
-        if not result:
-            return []
-
-        output = []
-
-        try:
-            formats = result.formats()
-            results = [result[format] for format in formats]
-
-            for ext, data in zip(formats, results):
-                match ext:
-                    case "png" | "svg" | "jpeg" | "pdf":
-                        document_file = self._save_to_disk(data, ext)
-                        output.append(
-                            InterpreterExtraResult(
-                                type=ext,
-                                filename=document_file.name,
-                                url=document_file.url,
-                            )
-                        )
-                    case _:
-                        # Try serialize data to string
-                        try:
-                            data = str(data)
-                        except Exception as e:
-                            data = f"Error when serializing data: {e}"
-                        output.append(
-                            InterpreterExtraResult(
-                                type=ext,
-                                content=data,
-                            )
-                        )
-        except Exception as error:
-            logger.exception(error, exc_info=True)
-            logger.error("Error when parsing output from E2b interpreter tool", error)
-
-        return output
-
-    def interpret(
-        self,
-        code: str,
-        sandbox_files: List[str] = [],
-        retry_count: int = 0,
-    ) -> E2BToolOutput:
-        """
-        Execute Python code in a Jupyter notebook cell. The tool will return the result, stdout, stderr, display_data, and error.
-        If the code needs to use a file, ALWAYS pass the file path in the sandbox_files argument.
-        You have a maximum of 3 retries to get the code to run successfully.
-
-        Parameters:
-            code (str): The Python code to be executed in a single cell.
-            sandbox_files (List[str]): List of local file paths to be used by the code. The tool will throw an error if a file is not found.
-            retry_count (int): Number of times the tool has been retried.
-        """
-        if retry_count > 2:
-            return E2BToolOutput(
-                is_error=True,
-                logs=Logs(
-                    stdout="",
-                    stderr="",
-                    display_data="",
-                    error="",
-                ),
-                error_message="Failed to execute the code after 3 retries. Explain the error to the user and suggest a fix.",
-                retry_count=retry_count,
-            )
-
-        if self.interpreter is None:
-            self._init_interpreter(sandbox_files)
-
-        if self.interpreter:
-            logger.info(
-                f"\n{'=' * 50}\n> Running following AI-generated code:\n{code}\n{'=' * 50}"
-            )
-            exec = self.interpreter.run_code(code)
-
-            if exec.error:
-                error_message = f"The code failed to execute successfully. Error: {exec.error}. Try to fix the code and run again."
-                logger.error(error_message)
-                # Calling the generated code caused an error. Kill the interpreter and return the error to the LLM so it can try to fix the error
-                try:
-                    self.interpreter.kill()  # type: ignore
-                except Exception:
-                    pass
-                finally:
-                    self.interpreter = None
-                output = E2BToolOutput(
-                    is_error=True,
-                    logs=exec.logs,
-                    results=[],
-                    error_message=error_message,
-                    retry_count=retry_count + 1,
-                )
-            else:
-                if len(exec.results) == 0:
-                    output = E2BToolOutput(is_error=False, logs=exec.logs, results=[])
-                else:
-                    results = self._parse_result(exec.results[0])
-                    output = E2BToolOutput(
-                        is_error=False,
-                        logs=exec.logs,
-                        results=results,
-                        retry_count=retry_count + 1,
-                    )
-            return output
-        else:
-            raise ValueError("Interpreter is not initialized.")
-
-
-def get_tools(**kwargs):
-    return [FunctionTool.from_defaults(E2BCodeInterpreter(**kwargs).interpret)]
@@ -1,187 +0,0 @@
-import os
-from typing import Any, Dict, List, Optional, Sequence
-
-from llama_index.core import get_response_synthesizer
-from llama_index.core.base.base_query_engine import BaseQueryEngine
-from llama_index.core.base.response.schema import RESPONSE_TYPE, Response
-from llama_index.core.multi_modal_llms import MultiModalLLM
-from llama_index.core.prompts.base import BasePromptTemplate
-from llama_index.core.prompts.default_prompt_selectors import (
-    DEFAULT_TEXT_QA_PROMPT_SEL,
-)
-from llama_index.core.query_engine.multi_modal import _get_image_and_text_nodes
-from llama_index.core.response_synthesizers.base import BaseSynthesizer, QueryTextType
-from llama_index.core.schema import (
-    ImageNode,
-    NodeWithScore,
-)
-from llama_index.core.tools.query_engine import QueryEngineTool
-from llama_index.core.types import RESPONSE_TEXT_TYPE
-
-from app.settings import get_multi_modal_llm
-
-
-def create_query_engine(index, **kwargs) -> BaseQueryEngine:
-    """
-    Create a query engine for the given index.
-
-    Args:
-        index: The index to create a query engine for.
-        params (optional): Additional parameters for the query engine, e.g: similarity_top_k
-    """
-
-    top_k = int(os.getenv("TOP_K", 0))
-    if top_k != 0 and kwargs.get("filters") is None:
-        kwargs["similarity_top_k"] = top_k
-    multimodal_llm = get_multi_modal_llm()
-    if multimodal_llm:
-        kwargs["response_synthesizer"] = MultiModalSynthesizer(
-            multimodal_model=multimodal_llm,
-        )
-
-    # If index is index is LlamaCloudIndex
-    # use auto_routed mode for better query results
-    if index.__class__.__name__ == "LlamaCloudIndex":
-        if kwargs.get("retrieval_mode") is None:
-            kwargs["retrieval_mode"] = "auto_routed"
-        if multimodal_llm:
-            kwargs["retrieve_image_nodes"] = True
-    return index.as_query_engine(**kwargs)
-
-
-def get_query_engine_tool(
-    index,
-    name: Optional[str] = None,
-    description: Optional[str] = None,
-    **kwargs,
-) -> QueryEngineTool:
-    """
-    Get a query engine tool for the given index.
-
-    Args:
-        index: The index to create a query engine for.
-        name (optional): The name of the tool.
-        description (optional): The description of the tool.
-    """
-    if name is None:
-        name = "query_index"
-    if description is None:
-        description = (
-            "Use this tool to retrieve information about the text corpus from an index."
-        )
-    query_engine = create_query_engine(index, **kwargs)
-    return QueryEngineTool.from_defaults(
-        query_engine=query_engine,
-        name=name,
-        description=description,
-    )
-
-
-class MultiModalSynthesizer(BaseSynthesizer):
-    """
-    A synthesizer that summarizes text nodes and uses a multi-modal LLM to generate a response.
-    """
-
-    def __init__(
-        self,
-        multimodal_model: MultiModalLLM,
-        response_synthesizer: Optional[BaseSynthesizer] = None,
-        text_qa_template: Optional[BasePromptTemplate] = None,
-        *args,
-        **kwargs,
-    ):
-        super().__init__(*args, **kwargs)
-        self._multi_modal_llm = multimodal_model
-        self._response_synthesizer = response_synthesizer or get_response_synthesizer()
-        self._text_qa_template = text_qa_template or DEFAULT_TEXT_QA_PROMPT_SEL
-
-    def _get_prompts(self, **kwargs) -> Dict[str, Any]:
-        return {
-            "text_qa_template": self._text_qa_template,
-        }
-
-    def _update_prompts(self, prompts: Dict[str, Any]) -> None:
-        if "text_qa_template" in prompts:
-            self._text_qa_template = prompts["text_qa_template"]
-
-    async def aget_response(
-        self,
-        *args,
-        **response_kwargs: Any,
-    ) -> RESPONSE_TEXT_TYPE:
-        return await self._response_synthesizer.aget_response(*args, **response_kwargs)
-
-    def get_response(self, *args, **kwargs) -> RESPONSE_TEXT_TYPE:
-        return self._response_synthesizer.get_response(*args, **kwargs)
-
-    async def asynthesize(
-        self,
-        query: QueryTextType,
-        nodes: List[NodeWithScore],
-        additional_source_nodes: Optional[Sequence[NodeWithScore]] = None,
-        **response_kwargs: Any,
-    ) -> RESPONSE_TYPE:
-        image_nodes, text_nodes = _get_image_and_text_nodes(nodes)
-
-        if len(image_nodes) == 0:
-            return await self._response_synthesizer.asynthesize(query, text_nodes)
-
-        # Summarize the text nodes to avoid exceeding the token limit
-        text_response = str(
-            await self._response_synthesizer.asynthesize(query, text_nodes)
-        )
-
-        fmt_prompt = self._text_qa_template.format(
-            context_str=text_response,
-            query_str=query.query_str,  # type: ignore
-        )
-
-        llm_response = await self._multi_modal_llm.acomplete(
-            prompt=fmt_prompt,
-            image_documents=[
-                image_node.node
-                for image_node in image_nodes
-                if isinstance(image_node.node, ImageNode)
-            ],
-        )
-
-        return Response(
-            response=str(llm_response),
-            source_nodes=nodes,
-            metadata={"text_nodes": text_nodes, "image_nodes": image_nodes},
-        )
-
-    def synthesize(
-        self,
-        query: QueryTextType,
-        nodes: List[NodeWithScore],
-        additional_source_nodes: Optional[Sequence[NodeWithScore]] = None,
-        **response_kwargs: Any,
-    ) -> RESPONSE_TYPE:
-        image_nodes, text_nodes = _get_image_and_text_nodes(nodes)
-
-        if len(image_nodes) == 0:
-            return self._response_synthesizer.synthesize(query, text_nodes)
-
-        # Summarize the text nodes to avoid exceeding the token limit
-        text_response = str(self._response_synthesizer.synthesize(query, text_nodes))
-
-        fmt_prompt = self._text_qa_template.format(
-            context_str=text_response,
-            query_str=query.query_str,  # type: ignore
-        )
-
-        llm_response = self._multi_modal_llm.complete(
-            prompt=fmt_prompt,
-            image_documents=[
-                image_node.node
-                for image_node in image_nodes
-                if isinstance(image_node.node, ImageNode)
-            ],
-        )
-
-        return Response(
-            response=str(llm_response),
-            source_nodes=nodes,
-            metadata={"text_nodes": text_nodes, "image_nodes": image_nodes},
-        )
@@ -1,296 +0,0 @@
-import { JSONSchemaType } from "ajv";
-import fs from "fs";
-import { BaseTool, Settings, ToolMetadata } from "llamaindex";
-import Papa from "papaparse";
-import path from "path";
-import { saveDocument } from "../../llamaindex/documents/helper";
-
-type ExtractMissingCellsParameter = {
-  filePath: string;
-};
-
-export type MissingCell = {
-  rowIndex: number;
-  columnIndex: number;
-  question: string;
-};
-
-const CSV_EXTRACTION_PROMPT = `You are a data analyst. You are given a table with missing cells.
-Your task is to identify the missing cells and the questions needed to fill them.
-IMPORTANT: Column indices should be 0-based
-
-# Instructions:
- Understand the entire content of the table and the topics of the table.
- Identify the missing cells and the meaning of the data in the cells.
- For each missing cell, provide the row index and the correct column index (remember: first data column is 1).
- For each missing cell, provide the question needed to fill the cell (it's important to provide the question that is relevant to the topic of the table).
- Since the cell's value should be concise, the question should request a numerical answer or a specific value.
- Finally, only return the answer in JSON format with the following schema:
-{
-  "missing_cells": [
-    {
-      "rowIndex": number,
-      "columnIndex": number,
-      "question": string
-    }
-  ]
-}
- If there are no missing cells, return an empty array.
- The answer is only the JSON object, nothing else and don't wrap it inside markdown code block.
-
-# Example:
-# |    | Name | Age | City |
-# |----|------|-----|------|
-# | 0  | John |     | Paris|
-# | 1  | Mary |     |      |
-# | 2  |      | 30  |      |
-#
-# Your thoughts:
-# - The table is about people's names, ages, and cities.
-# - Row: 1, Column: 2 (Age column), Question: "How old is Mary? Please provide only the numerical answer."
-# - Row: 1, Column: 3 (City column), Question: "In which city does Mary live? Please provide only the city name."
-# Your answer:
-# {
-#   "missing_cells": [
-#     {
-#       "rowIndex": 1,
-#       "columnIndex": 2,
-#       "question": "How old is Mary? Please provide only the numerical answer."
-#     },
-#     {
-#       "rowIndex": 1,
-#       "columnIndex": 3,
-#       "question": "In which city does Mary live? Please provide only the city name."
-#     }
-#   ]
-# }
-
-
-# Here is your task:
-
- Table content:
-{table_content}
-
- Your answer:
-`;
-
-const DEFAULT_METADATA: ToolMetadata<
-  JSONSchemaType<ExtractMissingCellsParameter>
-> = {
-  name: "extract_missing_cells",
-  description: `Use this tool to extract missing cells in a CSV file and generate questions to fill them. This tool only works with local file path.`,
-  parameters: {
-    type: "object",
-    properties: {
-      filePath: {
-        type: "string",
-        description: "The local file path to the CSV file.",
-      },
-    },
-    required: ["filePath"],
-  },
-};
-
-export interface ExtractMissingCellsParams {
-  metadata?: ToolMetadata<JSONSchemaType<ExtractMissingCellsParameter>>;
-}
-
-export class ExtractMissingCellsTool
-  implements BaseTool<ExtractMissingCellsParameter>
-{
-  metadata: ToolMetadata<JSONSchemaType<ExtractMissingCellsParameter>>;
-  defaultExtractionPrompt: string;
-
-  constructor(params: ExtractMissingCellsParams) {
-    this.metadata = params.metadata ?? DEFAULT_METADATA;
-    this.defaultExtractionPrompt = CSV_EXTRACTION_PROMPT;
-  }
-
-  private readCsvFile(filePath: string): Promise<string[][]> {
-    return new Promise((resolve, reject) => {
-      fs.readFile(filePath, "utf8", (err, data) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-
-        const parsedData = Papa.parse<string[]>(data, {
-          skipEmptyLines: false,
-        });
-
-        if (parsedData.errors.length) {
-          reject(parsedData.errors);
-          return;
-        }
-
-        // Ensure all rows have the same number of columns as the header
-        const maxColumns = parsedData.data[0].length;
-        const paddedRows = parsedData.data.map((row) => {
-          return [...row, ...Array(maxColumns - row.length).fill("")];
-        });
-
-        resolve(paddedRows);
-      });
-    });
-  }
-
-  private formatToMarkdownTable(data: string[][]): string {
-    if (data.length === 0) return "";
-
-    const maxColumns = data[0].length;
-
-    const headerRow = `| ${data[0].join(" | ")} |`;
-    const separatorRow = `| ${Array(maxColumns).fill("---").join(" | ")} |`;
-
-    const dataRows = data.slice(1).map((row) => {
-      return `| ${row.join(" | ")} |`;
-    });
-
-    return [headerRow, separatorRow, ...dataRows].join("\n");
-  }
-
-  async call(input: ExtractMissingCellsParameter): Promise<MissingCell[]> {
-    const { filePath } = input;
-    let tableContent: string[][];
-    try {
-      tableContent = await this.readCsvFile(filePath);
-    } catch (error) {
-      throw new Error(
-        `Failed to read CSV file. Make sure that you are reading a local file path (not a sandbox path).`,
-      );
-    }
-
-    const prompt = this.defaultExtractionPrompt.replace(
-      "{table_content}",
-      this.formatToMarkdownTable(tableContent),
-    );
-
-    const llm = Settings.llm;
-    const response = await llm.complete({
-      prompt,
-    });
-    const rawAnswer = response.text;
-    const parsedResponse = JSON.parse(rawAnswer) as {
-      missing_cells: MissingCell[];
-    };
-    if (!parsedResponse.missing_cells) {
-      throw new Error(
-        "The answer is not in the correct format. There should be a missing_cells array.",
-      );
-    }
-    const answer = parsedResponse.missing_cells;
-
-    return answer;
-  }
-}
-
-type FillMissingCellsParameter = {
-  filePath: string;
-  cells: {
-    rowIndex: number;
-    columnIndex: number;
-    answer: string;
-  }[];
-};
-
-const FILL_CELLS_METADATA: ToolMetadata<
-  JSONSchemaType<FillMissingCellsParameter>
-> = {
-  name: "fill_missing_cells",
-  description: `Use this tool to fill missing cells in a CSV file with provided answers. This tool only works with local file path.`,
-  parameters: {
-    type: "object",
-    properties: {
-      filePath: {
-        type: "string",
-        description: "The local file path to the CSV file.",
-      },
-      cells: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            rowIndex: { type: "number" },
-            columnIndex: { type: "number" },
-            answer: { type: "string" },
-          },
-          required: ["rowIndex", "columnIndex", "answer"],
-        },
-        description: "Array of cells to fill with their answers",
-      },
-    },
-    required: ["filePath", "cells"],
-  },
-};
-
-export interface FillMissingCellsParams {
-  metadata?: ToolMetadata<JSONSchemaType<FillMissingCellsParameter>>;
-}
-
-export class FillMissingCellsTool
-  implements BaseTool<FillMissingCellsParameter>
-{
-  metadata: ToolMetadata<JSONSchemaType<FillMissingCellsParameter>>;
-
-  constructor(params: FillMissingCellsParams = {}) {
-    this.metadata = params.metadata ?? FILL_CELLS_METADATA;
-  }
-
-  async call(input: FillMissingCellsParameter): Promise<string> {
-    const { filePath, cells } = input;
-
-    // Read the CSV file
-    const fileContent = await new Promise<string>((resolve, reject) => {
-      fs.readFile(filePath, "utf8", (err, data) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(data);
-        }
-      });
-    });
-
-    // Parse CSV with PapaParse
-    const parseResult = Papa.parse<string[]>(fileContent, {
-      header: false, // Ensure the header is not treated as a separate object
-      skipEmptyLines: false, // Ensure empty lines are not skipped
-    });
-
-    if (parseResult.errors.length) {
-      throw new Error(
-        "Failed to parse CSV file: " + parseResult.errors[0].message,
-      );
-    }
-
-    const rows = parseResult.data;
-
-    // Fill the cells with answers
-    for (const cell of cells) {
-      // Adjust rowIndex to start from 1 for data rows
-      const adjustedRowIndex = cell.rowIndex + 1;
-      if (
-        adjustedRowIndex < rows.length &&
-        cell.columnIndex < rows[adjustedRowIndex].length
-      ) {
-        rows[adjustedRowIndex][cell.columnIndex] = cell.answer;
-      }
-    }
-
-    // Convert back to CSV format
-    const updatedContent = Papa.unparse(rows, {
-      delimiter: parseResult.meta.delimiter,
-    });
-
-    // Use the helper function to write the file
-    const parsedPath = path.parse(filePath);
-    const newFileName = `${parsedPath.name}-filled${parsedPath.ext}`;
-    const newFilePath = path.join("output/tools", newFileName);
-
-    const newFileUrl = await saveDocument(newFilePath, updatedContent);
-
-    return (
-      "Successfully filled missing cells in the CSV file. File URL to show to the user: " +
-      newFileUrl
-    );
-  }
-}
@@ -1,57 +0,0 @@
-import {
-  BaseQueryEngine,
-  CloudRetrieveParams,
-  LlamaCloudIndex,
-  MetadataFilters,
-  QueryEngineTool,
-  VectorStoreIndex,
-} from "llamaindex";
-import { generateFilters } from "../queryFilter";
-
-interface QueryEngineParams {
-  documentIds?: string[];
-  topK?: number;
-}
-
-export function createQueryEngineTool(
-  index: VectorStoreIndex | LlamaCloudIndex,
-  params?: QueryEngineParams,
-  name?: string,
-  description?: string,
-): QueryEngineTool {
-  return new QueryEngineTool({
-    queryEngine: createQueryEngine(index, params),
-    metadata: {
-      name: name || "query_engine",
-      description:
-        description ||
-        `Use this tool to retrieve information about the text corpus from an index.`,
-    },
-  });
-}
-
-function createQueryEngine(
-  index: VectorStoreIndex | LlamaCloudIndex,
-  params?: QueryEngineParams,
-): BaseQueryEngine {
-  const baseQueryParams = {
-    similarityTopK:
-      params?.topK ??
-      (process.env.TOP_K ? parseInt(process.env.TOP_K) : undefined),
-  };
-
-  if (index instanceof LlamaCloudIndex) {
-    return index.asQueryEngine({
-      ...baseQueryParams,
-      retrieval_mode: "auto_routed",
-      preFilters: generateFilters(
-        params?.documentIds || [],
-      ) as CloudRetrieveParams["filters"],
-    });
-  }
-
-  return index.asQueryEngine({
-    ...baseQueryParams,
-    preFilters: generateFilters(params?.documentIds || []) as MetadataFilters,
-  });
-}
@@ -1,60 +0,0 @@
-import type { JSONSchemaType } from "ajv";
-import type { BaseTool, ToolMetadata } from "llamaindex";
-import { default as wiki } from "wikipedia";
-
-type WikipediaParameter = {
-  query: string;
-  lang?: string;
-};
-
-export type WikipediaToolParams = {
-  metadata?: ToolMetadata<JSONSchemaType<WikipediaParameter>>;
-};
-
-const DEFAULT_META_DATA: ToolMetadata<JSONSchemaType<WikipediaParameter>> = {
-  name: "wikipedia_tool",
-  description: "A tool that uses a query engine to search Wikipedia.",
-  parameters: {
-    type: "object",
-    properties: {
-      query: {
-        type: "string",
-        description: "The query to search for",
-      },
-      lang: {
-        type: "string",
-        description: "The language to search in",
-        nullable: true,
-      },
-    },
-    required: ["query"],
-  },
-};
-
-export class WikipediaTool implements BaseTool<WikipediaParameter> {
-  private readonly DEFAULT_LANG = "en";
-  metadata: ToolMetadata<JSONSchemaType<WikipediaParameter>>;
-
-  constructor(params?: WikipediaToolParams) {
-    this.metadata = params?.metadata || DEFAULT_META_DATA;
-  }
-
-  async loadData(
-    page: string,
-    lang: string = this.DEFAULT_LANG,
-  ): Promise<string> {
-    wiki.setLang(lang);
-    const pageResult = await wiki.page(page, { autoSuggest: false });
-    const content = await pageResult.content();
-    return content;
-  }
-
-  async call({
-    query,
-    lang = this.DEFAULT_LANG,
-  }: WikipediaParameter): Promise<string> {
-    const searchResult = await wiki.search(query);
-    if (searchResult.results.length === 0) return "No search results.";
-    return await this.loadData(searchResult.results[0].title, lang);
-  }
-}
@@ -1,48 +0,0 @@
-import {
-  Document,
-  IngestionPipeline,
-  Settings,
-  SimpleNodeParser,
-  storageContextFromDefaults,
-  VectorStoreIndex,
-} from "llamaindex";
-
-export async function runPipeline(
-  currentIndex: VectorStoreIndex | null,
-  documents: Document[],
-) {
-  // Use ingestion pipeline to process the documents into nodes and add them to the vector store
-  const pipeline = new IngestionPipeline({
-    transformations: [
-      new SimpleNodeParser({
-        chunkSize: Settings.chunkSize,
-        chunkOverlap: Settings.chunkOverlap,
-      }),
-      Settings.embedModel,
-    ],
-  });
-  const nodes = await pipeline.run({ documents });
-  if (currentIndex) {
-    await currentIndex.insertNodes(nodes);
-    currentIndex.storageContext.docStore.persist();
-    console.log("Added nodes to the vector store.");
-    return documents.map((document) => document.id_);
-  } else {
-    // Initialize a new index with the documents
-    console.log(
-      "Got empty index, created new index with the uploaded documents",
-    );
-    const persistDir = process.env.STORAGE_CACHE_DIR;
-    if (!persistDir) {
-      throw new Error("STORAGE_CACHE_DIR environment variable is required!");
-    }
-    const storageContext = await storageContextFromDefaults({
-      persistDir,
-    });
-    const newIndex = await VectorStoreIndex.fromDocuments(documents, {
-      storageContext,
-    });
-    await newIndex.storageContext.docStore.persist();
-    return documents.map((document) => document.id_);
-  }
-}
@@ -1,32 +0,0 @@
-import logging
-from abc import ABC, abstractmethod
-from typing import Any
-
-logger = logging.getLogger("uvicorn")
-
-
-class EventCallback(ABC):
-    """
-    Base class for event callbacks during event streaming.
-    """
-
-    async def run(self, event: Any) -> Any:
-        """
-        Called for each event in the stream.
-        Default behavior: pass through the event unchanged.
-        """
-        return event
-
-    async def on_complete(self, final_response: str) -> Any:
-        """
-        Called when the stream is complete.
-        Default behavior: return None.
-        """
-        return None
-
-    @abstractmethod
-    def from_default(self, *args, **kwargs) -> "EventCallback":
-        """
-        Create a new instance of the processor from default values.
-        """
-        pass
@@ -1,42 +0,0 @@
-import logging
-from typing import Any, List
-
-from fastapi import BackgroundTasks
-from llama_index.core.schema import NodeWithScore
-
-from app.api.callbacks.base import EventCallback
-
-logger = logging.getLogger("uvicorn")
-
-
-class LlamaCloudFileDownload(EventCallback):
-    """
-    Processor for handling LlamaCloud file downloads from source nodes.
-    Only work if LlamaCloud service code is available.
-    """
-
-    def __init__(self, background_tasks: BackgroundTasks):
-        self.background_tasks = background_tasks
-
-    async def run(self, event: Any) -> Any:
-        if hasattr(event, "to_response"):
-            event_response = event.to_response()
-            if event_response.get("type") == "sources" and hasattr(event, "nodes"):
-                await self._process_response_nodes(event.nodes)
-        return event
-
-    async def _process_response_nodes(self, source_nodes: List[NodeWithScore]):
-        try:
-            from app.engine.service import LLamaCloudFileService  # type: ignore
-
-            LLamaCloudFileService.download_files_from_nodes(
-                source_nodes, self.background_tasks
-            )
-        except ImportError:
-            pass
-
-    @classmethod
-    def from_default(
-        cls, background_tasks: BackgroundTasks
-    ) -> "LlamaCloudFileDownload":
-        return cls(background_tasks=background_tasks)
@@ -1,34 +0,0 @@
-import logging
-from typing import Any
-
-from app.api.callbacks.base import EventCallback
-from app.api.routers.models import ChatData
-from app.api.services.suggestion import NextQuestionSuggestion
-
-logger = logging.getLogger("uvicorn")
-
-
-class SuggestNextQuestions(EventCallback):
-    """Processor for generating next question suggestions."""
-
-    def __init__(self, chat_data: ChatData):
-        self.chat_data = chat_data
-        self.accumulated_text = ""
-
-    async def on_complete(self, final_response: str) -> Any:
-        if final_response == "":
-            return None
-
-        questions = await NextQuestionSuggestion.suggest_next_questions(
-            self.chat_data.messages, final_response
-        )
-        if questions:
-            return {
-                "type": "suggested_questions",
-                "data": questions,
-            }
-        return None
-
-    @classmethod
-    def from_default(cls, chat_data: ChatData) -> "SuggestNextQuestions":
-        return cls(chat_data=chat_data)
@@ -1,66 +0,0 @@
-import logging
-from typing import List, Optional
-
-from llama_index.core.workflow.handler import WorkflowHandler
-
-from app.api.callbacks.base import EventCallback
-
-logger = logging.getLogger("uvicorn")
-
-
-class StreamHandler:
-    """
-    Streams events from a workflow handler through a chain of callbacks.
-    """
-
-    def __init__(
-        self,
-        workflow_handler: WorkflowHandler,
-        callbacks: Optional[List[EventCallback]] = None,
-    ):
-        self.workflow_handler = workflow_handler
-        self.callbacks = callbacks or []
-        self.accumulated_text = ""
-
-    def vercel_stream(self):
-        """Create a streaming response with Vercel format."""
-        from app.api.routers.vercel_response import VercelStreamResponse
-
-        return VercelStreamResponse(stream_handler=self)
-
-    async def cancel_run(self):
-        """Cancel the workflow handler."""
-        await self.workflow_handler.cancel_run()
-
-    async def stream_events(self):
-        """Stream events through the processor chain."""
-        try:
-            async for event in self.workflow_handler.stream_events():
-                # Process the event through each processor
-                for callback in self.callbacks:
-                    event = await callback.run(event)
-                yield event
-
-            # After all events are processed, call on_complete for each callback
-            for callback in self.callbacks:
-                result = await callback.on_complete(self.accumulated_text)
-                if result:
-                    yield result
-
-        except Exception as e:
-            # Make sure to cancel the workflow on error
-            await self.workflow_handler.cancel_run()
-            raise e
-
-    async def accumulate_text(self, text: str):
-        """Accumulate text from the workflow handler."""
-        self.accumulated_text += text
-
-    @classmethod
-    def from_default(
-        cls,
-        handler: WorkflowHandler,
-        callbacks: Optional[List[EventCallback]] = None,
-    ) -> "StreamHandler":
-        """Create a new instance with the given workflow handler and callbacks."""
-        return cls(workflow_handler=handler, callbacks=callbacks)
@@ -1,55 +0,0 @@
-import logging
-
-from fastapi import APIRouter, BackgroundTasks, HTTPException, Request, status
-
-from app.api.callbacks.llamacloud import LlamaCloudFileDownload
-from app.api.callbacks.next_question import SuggestNextQuestions
-from app.api.callbacks.stream_handler import StreamHandler
-from app.api.routers.models import (
-    ChatData,
-)
-from app.engine.query_filter import generate_filters
-from app.workflows import create_workflow
-
-chat_router = r = APIRouter()
-
-logger = logging.getLogger("uvicorn")
-
-
-@r.post("")
-async def chat(
-    request: Request,
-    data: ChatData,
-    background_tasks: BackgroundTasks,
-):
-    try:
-        last_message_content = data.get_last_message_content()
-        messages = data.get_history_messages(include_agent_messages=True)
-
-        doc_ids = data.get_chat_document_ids()
-        filters = generate_filters(doc_ids)
-        params = data.data or {}
-
-        workflow = create_workflow(
-            params=params,
-            filters=filters,
-        )
-
-        handler = workflow.run(
-            user_msg=last_message_content,
-            chat_history=messages,
-            stream=True,
-        )
-        return StreamHandler.from_default(
-            handler=handler,
-            callbacks=[
-                LlamaCloudFileDownload.from_default(background_tasks),
-                SuggestNextQuestions.from_default(data),
-            ],
-        ).vercel_stream()
-    except Exception as e:
-        logger.exception("Error in chat engine", exc_info=True)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Error in chat engine: {e}",
-        ) from e
@@ -1,99 +0,0 @@
-import asyncio
-import json
-import logging
-from typing import AsyncGenerator
-
-from fastapi.responses import StreamingResponse
-from llama_index.core.agent.workflow.workflow_events import AgentStream
-from llama_index.core.workflow import StopEvent
-
-from app.api.callbacks.stream_handler import StreamHandler
-
-logger = logging.getLogger("uvicorn")
-
-
-class VercelStreamResponse(StreamingResponse):
-    """
-    Converts preprocessed events into Vercel-compatible streaming response format.
-    """
-
-    TEXT_PREFIX = "0:"
-    DATA_PREFIX = "8:"
-    ERROR_PREFIX = "3:"
-
-    def __init__(
-        self,
-        stream_handler: StreamHandler,
-        *args,
-        **kwargs,
-    ):
-        self.handler = stream_handler
-        super().__init__(content=self.content_generator())
-
-    async def content_generator(self):
-        """Generate Vercel-formatted content from preprocessed events."""
-        stream_started = False
-        try:
-            async for event in self.handler.stream_events():
-                if not stream_started:
-                    # Start the stream with an empty message
-                    stream_started = True
-                    yield self.convert_text("")
-
-                # Handle different types of events
-                if isinstance(event, (AgentStream, StopEvent)):
-                    async for chunk in self._stream_text(event):
-                        await self.handler.accumulate_text(chunk)
-                        yield self.convert_text(chunk)
-                elif isinstance(event, dict):
-                    yield self.convert_data(event)
-                elif hasattr(event, "to_response"):
-                    event_response = event.to_response()
-                    yield self.convert_data(event_response)
-                else:
-                    yield self.convert_data(event.model_dump())
-
-        except asyncio.CancelledError:
-            logger.warning("Client cancelled the request!")
-            await self.handler.cancel_run()
-        except Exception as e:
-            logger.error(f"Error in stream response: {e}")
-            yield self.convert_error(str(e))
-            await self.handler.cancel_run()
-
-    async def _stream_text(
-        self, event: AgentStream | StopEvent
-    ) -> AsyncGenerator[str, None]:
-        """
-        Accept stream text from either AgentStream or StopEvent with string or AsyncGenerator result
-        """
-        if isinstance(event, AgentStream):
-            yield self.convert_text(event.delta)
-        elif isinstance(event, StopEvent):
-            if isinstance(event.result, str):
-                yield event.result
-            elif isinstance(event.result, AsyncGenerator):
-                async for chunk in event.result:
-                    if isinstance(chunk, str):
-                        yield chunk
-                    elif hasattr(chunk, "delta"):
-                        yield chunk.delta
-
-    @classmethod
-    def convert_text(cls, token: str) -> str:
-        """Convert text event to Vercel format."""
-        # Escape newlines and double quotes to avoid breaking the stream
-        token = json.dumps(token)
-        return f"{cls.TEXT_PREFIX}{token}\n"
-
-    @classmethod
-    def convert_data(cls, data: dict) -> str:
-        """Convert data event to Vercel format."""
-        data_str = json.dumps(data)
-        return f"{cls.DATA_PREFIX}[{data_str}]\n"
-
-    @classmethod
-    def convert_error(cls, error: str) -> str:
-        """Convert error event to Vercel format."""
-        error_str = json.dumps(error)
-        return f"{cls.ERROR_PREFIX}{error_str}\n"
@@ -1,45 +0,0 @@
-from enum import Enum
-from typing import List, Optional
-
-from llama_index.core.schema import NodeWithScore
-from llama_index.core.workflow import Event
-
-from app.api.routers.models import SourceNodes
-
-
-class AgentRunEventType(Enum):
-    TEXT = "text"
-    PROGRESS = "progress"
-
-
-class AgentRunEvent(Event):
-    name: str
-    msg: str
-    event_type: AgentRunEventType = AgentRunEventType.TEXT
-    data: Optional[dict] = None
-
-    def to_response(self) -> dict:
-        return {
-            "type": "agent",
-            "data": {
-                "agent": self.name,
-                "type": self.event_type.value,
-                "text": self.msg,
-                "data": self.data,
-            },
-        }
-
-
-class SourceNodesEvent(Event):
-    nodes: List[NodeWithScore]
-
-    def to_response(self):
-        return {
-            "type": "sources",
-            "data": {
-                "nodes": [
-                    SourceNodes.from_source_node(node).model_dump()
-                    for node in self.nodes
-                ]
-            },
-        }
@@ -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())
@@ -1,230 +0,0 @@
-import logging
-import uuid
-from abc import ABC, abstractmethod
-from typing import Any, AsyncGenerator, Callable, Optional
-
-from llama_index.core.base.llms.types import ChatMessage, ChatResponse, MessageRole
-from llama_index.core.llms.function_calling import FunctionCallingLLM
-from llama_index.core.tools import (
-    BaseTool,
-    FunctionTool,
-    ToolOutput,
-    ToolSelection,
-)
-from llama_index.core.workflow import Context
-from pydantic import BaseModel, ConfigDict
-
-from app.workflows.events import AgentRunEvent, AgentRunEventType
-
-logger = logging.getLogger("uvicorn")
-
-
-class ContextAwareTool(FunctionTool, ABC):
-    @abstractmethod
-    async def acall(self, ctx: Context, input: Any) -> ToolOutput:  # type: ignore
-        pass
-
-
-class ChatWithToolsResponse(BaseModel):
-    """
-    A tool call response from chat_with_tools.
-    """
-
-    tool_calls: Optional[list[ToolSelection]]
-    tool_call_message: Optional[ChatMessage]
-    generator: Optional[AsyncGenerator[ChatResponse | None, None]]
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    def is_calling_different_tools(self) -> bool:
-        tool_names = {tool_call.tool_name for tool_call in self.tool_calls}
-        return len(tool_names) > 1
-
-    def has_tool_calls(self) -> bool:
-        return self.tool_calls is not None and len(self.tool_calls) > 0
-
-    def tool_name(self) -> str:
-        assert self.has_tool_calls()
-        assert not self.is_calling_different_tools()
-        return self.tool_calls[0].tool_name
-
-    async def full_response(self) -> str:
-        assert self.generator is not None
-        full_response = ""
-        async for chunk in self.generator:
-            content = chunk.message.content
-            if content:
-                full_response += content
-        return full_response
-
-
-async def chat_with_tools(  # type: ignore
-    llm: FunctionCallingLLM,
-    tools: list[BaseTool],
-    chat_history: list[ChatMessage],
-) -> ChatWithToolsResponse:
-    """
-    Request LLM to call tools or not.
-    This function doesn't change the memory.
-    """
-    generator = _tool_call_generator(llm, tools, chat_history)
-    is_tool_call = await generator.__anext__()
-    if is_tool_call:
-        # Last chunk is the full response
-        # Wait for the last chunk
-        full_response = None
-        async for chunk in generator:
-            full_response = chunk
-        assert isinstance(full_response, ChatResponse)
-        return ChatWithToolsResponse(
-            tool_calls=llm.get_tool_calls_from_response(full_response),
-            tool_call_message=full_response.message,
-            generator=None,
-        )
-    else:
-        return ChatWithToolsResponse(
-            tool_calls=None,
-            tool_call_message=None,
-            generator=generator,
-        )
-
-
-async def call_tools(
-    ctx: Context,
-    agent_name: str,
-    tools: list[BaseTool],
-    tool_calls: list[ToolSelection],
-    emit_agent_events: bool = True,
-) -> list[ChatMessage]:
-    if len(tool_calls) == 0:
-        return []
-
-    tools_by_name = {tool.metadata.get_name(): tool for tool in tools}
-    if len(tool_calls) == 1:
-        return [
-            await call_tool(
-                ctx,
-                tools_by_name[tool_calls[0].tool_name],
-                tool_calls[0],
-                lambda msg: ctx.write_event_to_stream(
-                    AgentRunEvent(
-                        name=agent_name,
-                        msg=msg,
-                    )
-                ),
-            )
-        ]
-    # Multiple tool calls, show progress
-    tool_msgs: list[ChatMessage] = []
-
-    progress_id = str(uuid.uuid4())
-    total_steps = len(tool_calls)
-    if emit_agent_events:
-        ctx.write_event_to_stream(
-            AgentRunEvent(
-                name=agent_name,
-                msg=f"Making {total_steps} tool calls",
-            )
-        )
-    for i, tool_call in enumerate(tool_calls):
-        tool = tools_by_name.get(tool_call.tool_name)
-        if not tool:
-            tool_msgs.append(
-                ChatMessage(
-                    role=MessageRole.ASSISTANT,
-                    content=f"Tool {tool_call.tool_name} does not exist",
-                )
-            )
-            continue
-        tool_msg = await call_tool(
-            ctx,
-            tool,
-            tool_call,
-            event_emitter=lambda msg: ctx.write_event_to_stream(
-                AgentRunEvent(
-                    name=agent_name,
-                    msg=msg,
-                    event_type=AgentRunEventType.PROGRESS,
-                    data={
-                        "id": progress_id,
-                        "total": total_steps,
-                        "current": i,
-                    },
-                )
-            ),
-        )
-        tool_msgs.append(tool_msg)
-    return tool_msgs
-
-
-async def call_tool(
-    ctx: Context,
-    tool: BaseTool,
-    tool_call: ToolSelection,
-    event_emitter: Optional[Callable[[str], None]],
-) -> ChatMessage:
-    if event_emitter:
-        event_emitter(
-            f"Calling tool {tool_call.tool_name}, {str(tool_call.tool_kwargs)}"
-        )
-    try:
-        if isinstance(tool, ContextAwareTool):
-            if ctx is None:
-                raise ValueError("Context is required for context aware tool")
-            # inject context for calling an context aware tool
-            response = await tool.acall(ctx=ctx, **tool_call.tool_kwargs)
-        else:
-            response = await tool.acall(**tool_call.tool_kwargs)  # type: ignore
-        return ChatMessage(
-            role=MessageRole.TOOL,
-            content=str(response.raw_output),
-            additional_kwargs={
-                "tool_call_id": tool_call.tool_id,
-                "name": tool.metadata.get_name(),
-            },
-        )
-    except Exception as e:
-        logger.error(f"Got error in tool {tool_call.tool_name}: {str(e)}")
-        if event_emitter:
-            event_emitter(f"Got error in tool {tool_call.tool_name}: {str(e)}")
-        return ChatMessage(
-            role=MessageRole.TOOL,
-            content=f"Error: {str(e)}",
-            additional_kwargs={
-                "tool_call_id": tool_call.tool_id,
-                "name": tool.metadata.get_name(),
-            },
-        )
-
-
-async def _tool_call_generator(
-    llm: FunctionCallingLLM,
-    tools: list[BaseTool],
-    chat_history: list[ChatMessage],
-) -> AsyncGenerator[ChatResponse | bool, None]:
-    response_stream = await llm.astream_chat_with_tools(
-        tools,
-        chat_history=chat_history,
-        allow_parallel_tool_calls=False,
-    )
-
-    full_response = None
-    yielded_indicator = False
-    async for chunk in response_stream:
-        if "tool_calls" not in chunk.message.additional_kwargs:
-            # Yield a boolean to indicate whether the response is a tool call
-            if not yielded_indicator:
-                yield False
-                yielded_indicator = True
-
-            # if not a tool call, yield the chunks!
-            yield chunk  # type: ignore
-        elif not yielded_indicator:
-            # Yield the indicator for a tool call
-            yield True
-            yielded_indicator = True
-
-        full_response = chunk
-
-    if full_response:
-        yield full_response  # type: ignore
@@ -1,51 +0,0 @@
-import { LlamaIndexAdapter, Message } from "ai";
-import { Request, Response } from "express";
-import {
-  convertToChatHistory,
-  retrieveMessageContent,
-} from "./llamaindex/streaming/annotations";
-import { createWorkflow } from "./workflow/factory";
-import { createStreamFromWorkflowContext } from "./workflow/stream";
-
-export const chat = async (req: Request, res: Response) => {
-  try {
-    const { messages }: { messages: Message[] } = req.body;
-    if (!messages || messages.length === 0) {
-      return res.status(400).json({
-        error: "messages are required in the request body",
-      });
-    }
-    const chatHistory = convertToChatHistory(messages);
-    const userMessageContent = retrieveMessageContent(messages);
-
-    const workflow = await createWorkflow({ chatHistory });
-
-    const context = workflow.run({
-      message: userMessageContent,
-      streaming: true,
-    });
-
-    const { stream, dataStream } =
-      await createStreamFromWorkflowContext(context);
-
-    const streamResponse = LlamaIndexAdapter.toDataStreamResponse(stream, {
-      data: dataStream,
-    });
-    if (streamResponse.body) {
-      const reader = streamResponse.body.getReader();
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          res.end();
-          return;
-        }
-        res.write(value);
-      }
-    }
-  } catch (error) {
-    console.error("[LlamaIndex]", error);
-    return res.status(500).json({
-      detail: (error as Error).message,
-    });
-  }
-};
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Marcus Schiesser	f886e3132b	review fixes	2024-10-14 12:34:06 +07:00
Marcus Schiesser	4015c157b6	fix: use cli framework in CLI	2024-10-14 12:27:53 +07:00
Marcus Schiesser	8539c7ddec	Merge branch 'main' into ms/simplify	2024-10-14 12:08:45 +07:00
Marcus Schiesser	24fcde52f2	add data sources for simple templates	2024-10-14 12:05:49 +07:00
Marcus Schiesser	40dc3a48b4	fix: llamacloud is not a datasource	2024-10-14 12:03:03 +07:00
Marcus Schiesser	ff2d1a1e87	ask for llamacloud key in simple mode	2024-10-14 11:22:45 +07:00
Marcus Schiesser	40b9c01b0d	fix: don't override cli defaults in pro mode	2024-10-14 10:51:54 +07:00
Marcus Schiesser	e3b54e60fd	factor out CI defaults	2024-10-11 16:58:29 +07:00
Marcus Schiesser	4e600778e8	remove askExamples	2024-10-11 16:39:36 +07:00
Marcus Schiesser	56088bd3d7	remove preferences	2024-10-11 16:37:50 +07:00
Marcus Schiesser	f00cb5aa03	use pro for CI	2024-10-11 16:33:16 +07:00
Marcus Schiesser	3bb5af8d5f	add postinstall question to simple questions	2024-10-11 16:19:49 +07:00
Marcus Schiesser	b7af20762c	chore: order types	2024-10-11 15:43:05 +07:00
Marcus Schiesser	6e51bcd81a	feat: add simple questions	2024-10-11 15:30:05 +07:00
Marcus Schiesser	5ba4b3bcf1	chore: update prompts	2024-10-11 11:56:19 +07:00
Marcus Schiesser	571a8c3a12	use new commander features	2024-10-11 11:44:14 +07:00
Marcus Schiesser	c89e85bf4e	chore: use latest commander	2024-10-11 11:25:45 +07:00