Langfuse on Producthunt daily

local-ai-packaged

Mon, 02 Jun 2025 15:31:52 +0800

coleam00/local-ai-packaged

Self-hosted AI Package

Self-hosted AI Package is an open, docker compose template that quickly bootstraps a fully featured Local AI and Low Code development environment including Ollama for your local LLMs, Open WebUI for an interface to chat with your N8N agents, and Supabase for your database, vector store, and authentication.

This is Cole’s version with a couple of improvements and the addition of Supabase, Open WebUI, Flowise, Neo4j, Langfuse, SearXNG, and Caddy! Also, the local RAG AI Agent workflows from the video will be automatically in your n8n instance if you use this setup instead of the base one provided by n8n!

Important Links

Local AI community forum over in the oTTomator Think Tank
GitHub Kanban board for feature implementation and bug squashing.
Original Local AI Starter Kit by the n8n team
Download my N8N + OpenWebUI integration directly on the Open WebUI site. (more instructions below)

Curated by https://github.com/n8n-io and https://github.com/coleam00, it combines the self-hosted n8n platform with a curated list of compatible AI products and components to quickly get started with building self-hosted AI workflows.

What’s included

✅ Self-hosted n8n - Low-code platform with over 400 integrations and advanced AI components

✅ Supabase - Open source database as a service - most widely used database for AI agents

✅ Ollama - Cross-platform LLM platform to install and run the latest local LLMs

✅ Open WebUI - ChatGPT-like interface to privately interact with your local models and N8N agents

✅ Flowise - No/low code AI agent builder that pairs very well with n8n

✅ Qdrant - Open source, high performance vector store with an comprehensive API. Even though you can use Supabase for RAG, this was kept unlike Postgres since it’s faster than Supabase so sometimes is the better option.

✅ Neo4j - Knowledge graph engine that powers tools like GraphRAG, LightRAG, and Graphiti

✅ SearXNG - Open source, free internet metasearch engine which aggregates results from up to 229 search services. Users are neither tracked nor profiled, hence the fit with the local AI package.

✅ Caddy - Managed HTTPS/TLS for custom domains

✅ Langfuse - Open source LLM engineering platform for agent observability

Prerequisites

Before you begin, make sure you have the following software installed:

Python - Required to run the setup script
Git/GitHub Desktop - For easy repository management
Docker/Docker Desktop - Required to run all services

Installation

Clone the repository and navigate to the project directory:

1
2

git clone -b stable https://github.com/coleam00/local-ai-packaged.git
cd local-ai-packaged

Before running the services, you need to set up your environment variables for Supabase following their self-hosting guide.

Make a copy of .env.example and rename it to .env in the root directory of the project

Set the following required environment variables:

############
# N8N Configuration
############
N8N_ENCRYPTION_KEY=
N8N_USER_MANAGEMENT_JWT_SECRET=

############
# Supabase Secrets
############
POSTGRES_PASSWORD=
JWT_SECRET=
ANON_KEY=
SERVICE_ROLE_KEY=
DASHBOARD_USERNAME=
DASHBOARD_PASSWORD=
POOLER_TENANT_ID=

############
# Neo4j Secrets
############   
NEO4J_AUTH=

############
# Langfuse credentials
############

CLICKHOUSE_PASSWORD=
MINIO_ROOT_PASSWORD=
LANGFUSE_SALT=
NEXTAUTH_SECRET=
ENCRYPTION_KEY=

[!IMPORTANT] Make sure to generate secure random values for all secrets. Never use the example values in production.

Set the following environment variables if deploying to production, otherwise leave commented:

############
# Caddy Config
############

N8N_HOSTNAME=n8n.yourdomain.com
WEBUI_HOSTNAME=:openwebui.yourdomain.com
FLOWISE_HOSTNAME=:flowise.yourdomain.com
SUPABASE_HOSTNAME=:supabase.yourdomain.com
OLLAMA_HOSTNAME=:ollama.yourdomain.com
SEARXNG_HOSTNAME=searxng.yourdomain.com
NEO4J_HOSTNAME=neo4j.yourdomain.com
LETSENCRYPT_EMAIL=your-email-address

The project includes a start_services.py script that handles starting both the Supabase and local AI services. The script accepts a --profile flag to specify which GPU configuration to use.

For Nvidia GPU users

`1`	`python start_services.py --profile gpu-nvidia`

[!NOTE] If you have not used your Nvidia GPU with Docker before, please follow the Ollama Docker instructions.

For AMD GPU users on Linux

`1`	`python start_services.py --profile gpu-amd`

For Mac / Apple Silicon users

If you’re using a Mac with an M1 or newer processor, you can’t expose your GPU to the Docker instance, unfortunately. There are two options in this case:

Run the starter kit fully on CPU:

`1`	`python start_services.py --profile cpu`

Run Ollama on your Mac for faster inference, and connect to that from the n8n instance:
1

python start_services.py --profile none
If you want to run Ollama on your mac, check the Ollama homepage for installation instructions.

For Mac users running OLLAMA locally

If you’re running OLLAMA locally on your Mac (not in Docker), you need to modify the OLLAMA_HOST environment variable in the n8n service configuration. Update the x-n8n section in your Docker Compose file as follows:

x-n8n: &service-n8n
  # ... other configurations ...
  environment:
    # ... other environment variables ...
    - OLLAMA_HOST=host.docker.internal:11434

Additionally, after you see “Editor is now accessible via: http://localhost:5678/”:

Head to http://localhost:5678/home/credentials
Click on “Local Ollama service”
Change the base URL to “http://host.docker.internal:11434/"

For everyone else

`1`	`python start_services.py --profile cpu`

The environment argument

The start-services.py script offers the possibility to pass one of two options for the environment argument, private (default environment) and public:

private: you are deploying the stack in a safe environment, hence a lot of ports can be made accessible without having to worry about security
public: the stack is deployed in a public environment, which means the attack surface should be made as small as possible. All ports except for 80 and 443 are closed

The stack initialized with

`1`	`python start_services.py --profile gpu-nvidia --environment private`

equals the one initialized with

`1`	`python start_services.py --profile gpu-nvidia`

Deploying to the Cloud

Prerequisites for the below steps

Linux machine (preferably Unbuntu) with Nano, Git, and Docker installed

Extra steps

Before running the above commands to pull the repo and install everything:

Run the commands as root to open up the necessary ports:
- ufw enable
- ufw allow 80 && ufw allow 443
- ufw reload
WARNING

ufw does not shield ports published by docker, because the iptables rules configured by docker are analyzed before those configured by ufw. There is a solution to change this behavior, but that is out of scope for this project. Just make sure that all traffic runs through the caddy service via port 443. Port 80 should only be used to redirect to port 443.
Run the start-services.py script with the environment argument public to indicate you are going to run the package in a public environment. The script will make sure that all ports, except for 80 and 443, are closed down, e.g.

`1`	`python start_services.py --profile gpu-nvidia --environment public`

Set up A records for your DNS provider to point your subdomains you’ll set up in the .env file for Caddy to the IP address of your cloud instance.

For example, A record to point n8n to [cloud instance IP] for n8n.yourdomain.com

⚡️ Quick start and usage

The main component of the self-hosted AI starter kit is a docker compose file pre-configured with network and disk so there isn’t much else you need to install. After completing the installation steps above, follow the steps below to get started.

Open http://localhost:5678/ in your browser to set up n8n. You’ll only have to do this once. You are NOT creating an account with n8n in the setup here, it is only a local account for your instance!
Open the included workflow: http://localhost:5678/workflow/vTN9y2dLXqTiDfPT
Create credentials for every service:

Ollama URL: http://ollama:11434

Postgres (through Supabase): use DB, username, and password from .env. IMPORTANT: Host is ‘db’ Since that is the name of the service running Supabase

Qdrant URL: http://qdrant:6333 (API key can be whatever since this is running locally)

Google Drive: Follow this guide from n8n. Don’t use localhost for the redirect URI, just use another domain you have, it will still work! Alternatively, you can set up local file triggers.
Select Test workflow to start running the workflow.
If this is the first time you’re running the workflow, you may need to wait until Ollama finishes downloading Llama3.1. You can inspect the docker console logs to check on the progress.
Make sure to toggle the workflow as active and copy the “Production” webhook URL!
Open http://localhost:3000/ in your browser to set up Open WebUI. You’ll only have to do this once. You are NOT creating an account with Open WebUI in the setup here, it is only a local account for your instance!
Go to Workspace -> Functions -> Add Function -> Give name + description then paste in the code from n8n_pipe.py

The function is also published here on Open WebUI’s site.
Click on the gear icon and set the n8n_url to the production URL for the webhook you copied in a previous step.
Toggle the function on and now it will be available in your model dropdown in the top left!

To open n8n at any time, visit http://localhost:5678/ in your browser. To open Open WebUI at any time, visit http://localhost:3000/.

With your n8n instance, you’ll have access to over 400 integrations and a suite of basic and advanced AI nodes such as AI Agent, Text classifier, and Information Extractor nodes. To keep everything local, just remember to use the Ollama node for your language model and Qdrant as your vector store.

[!NOTE] This starter kit is designed to help you get started with self-hosted AI workflows. While it’s not fully optimized for production environments, it combines robust components that work well together for proof-of-concept projects. You can customize it to meet your specific needs

Upgrading

To update all containers to their latest versions (n8n, Open WebUI, etc.), run these commands:

# Stop all services
docker compose -p localai -f docker-compose.yml --profile <your-profile> down

# Pull latest versions of all containers
docker compose -p localai -f docker-compose.yml --profile <your-profile> pull

# Start services again with your desired profile
python start_services.py --profile <your-profile>

Replace <your-profile> with one of: cpu, gpu-nvidia, gpu-amd, or none.

Note: The start_services.py script itself does not update containers - it only restarts them or pulls them if you are downloading these containers for the first time. To get the latest versions, you must explicitly run the commands above.

Troubleshooting

Here are solutions to common issues you might encounter:

Supabase Issues

Supabase Pooler Restarting: If the supabase-pooler container keeps restarting itself, follow the instructions in this GitHub issue.
Supabase Analytics Startup Failure: If the supabase-analytics container fails to start after changing your Postgres password, delete the folder supabase/docker/volumes/db/data.
If using Docker Desktop: Go into the Docker settings and make sure “Expose daemon on tcp://localhost:2375 without TLS” is turned on
Supabase Service Unavailable - Make sure you don’t have an “@” character in your Postgres password! If the connection to the kong container is working (the container logs say it is receiving requests from n8n) but n8n says it cannot connect, this is generally the problem from what the community has shared. Other characters might not be allowed too, the @ symbol is just the one I know for sure!

GPU Support Issues

Windows GPU Support: If you’re having trouble running Ollama with GPU support on Windows with Docker Desktop:
1. Open Docker Desktop settings
2. Enable WSL 2 backend
3. See the Docker GPU documentation for more details
Linux GPU Support: If you’re having trouble running Ollama with GPU support on Linux, follow the Ollama Docker instructions.

👓 Recommended reading

n8n is full of useful content for getting started quickly with its AI concepts and nodes. If you run into an issue, go to support.

🎥 Video walkthrough

Cole’s Guide to the Local AI Starter Kit

🛍️ More AI templates

For more AI workflow ideas, visit the official n8n AI template gallery. From each workflow, select the Use workflow button to automatically import the workflow into your local n8n instance.

Learn AI key concepts

Local AI templates

Tips & tricks

Accessing local files

The self-hosted AI starter kit will create a shared folder (by default, located in the same directory) which is mounted to the n8n container and allows n8n to access files on disk. This folder within the n8n container is located at /data/shared – this is the path you’ll need to use in nodes that interact with the local filesystem.

Nodes that interact with the local filesystem

📜 License

This project (originally created by the n8n team, link at the top of the README) is licensed under the Apache License 2.0 - see the LICENSE file for details.

3rd-devs

Thu, 15 May 2025 15:30:07 +0800

i-am-alice/3rd-devs

AI_devs 3

Repozytorium zawiera przykłady z lekcji kursu AI_devs 3. Więcej informacji znajdziesz na aidevs.pl.

Wymagania

Wszystkie przykłady zostały napisane w JavaScript / TypeScript i większość z nich zawiera kod backendowy do którego uruchomienia potrzebny jest Node.js oraz Bun.

Node.js
Bun

Upewnij się, że posiadasz najnowsze wersje Node.js oraz Bun zainstalowane na swoim komputerze.

Instalacja

Pobierz repozytorium:

1
2

git clone git@github.com:i-am-alice/3rd-devs.git
cd 3rd-devs

Zainstaluj zależności:
1

bun install
Skopiuj plik .env.example do .env i wypełnij go kluczami API (na początek wystarczy klucz OpenAI).
Uruchom dostępne przykłady z pliku package.json, według poniższej instrukcji.

Instalacja — DOCKER

Jeśli posiadasz w swoim systemie możliwość uruchamiania kontenerów Dockera (na Windows użyj np. WSL/WSL2), możesz wykorzystać skrypt, który zbuduje i uruchomi dla Ciebie kontener ze środowiskiem gotowym do pracy.

Wejdź do katalogu, w którym chcesz przetrzymywać pliki środowiska i wydaj następujące polecenia:
1 2

curl -fsSL https://env.ag3nts.org -o setup.sh bash setup.sh
Powyższy skrypt NIE zmienia niczego w systemie. Wykonuje on następujące czynności:
- klonowanie repozytorium do katalogu “3rd-devs” (poza kontenerem, w aktualnym katalogu)
- przygotowanie pliku Dockerfile
- usunięcie starego obrazu Dockera o nazwie “aidevs” (jeśli istnieje)
- uruchomienie procesu budowy obrazu Dockera
- instalacja wymaganych paczek wewnątrz zdokeryzowanego środowiska
Po pomyślnym zbudowaniu obrazu możesz uruchomić go poleceniem (jeśli port 3000 masz zajęty, wybierz inny):
1

docker run --rm -it -p 3000:3000 --name aidevs -v ${PWD}/3rd-devs:/app aidevs3
Pliki w katalogu “3rd-devs” możesz modyfikować w dowolnym IDE. Będą one bezpośrednio widoczne wewnątrz kontenera
Będąc już wewnątrz kontenera, skopiuj plik .env.example do .env i wypełnij go wymaganymi kluczami API (na początek wystarczy klucz OpenAI).
Twoje środowisko jest gotowe do pracy.

S01E01

Thread

Przykład przedstawia konwersację między użytkownikiem i asystentem, w której działa mechanizm podsumowania konwersacji.

Uruchomienie serwera: bun run thread
Interakcja demo: curl -X POST http://localhost:3000/api/demo
Interakcja chat: curl -X POST http://localhost:3000/api/chat -H "Content-Type: application/json" -d '{"message": { "role": "user", "content": "Hi"}}'

Wywołanie powyższego endpointu uruchomi trzy niezależne zapytania do OpenAI, jednak w wiadomości systemowej zostanie przekazane podsumowanie poprzedniej interakcji, dzięki czemu model będzie miał możliwość odwołać się do ich treści.

W przykładzie uwzględniony jest także endpoint /api/chat na który można przesłać obiekt { “message”: “…” } zawierający treść wiadomości do modelu. Wątek zostanie zresetowany dopiero po ponownym uruchomieniu serwera (wciśnij CMD + C / Control + C i ponownie bun run thread).

Use Search

UWAGA: przykład wymaga zainstalowania promptfoo w przypadku którego prawdopodobnie musisz to zrobić poleceniem npm install promptfoo ponieważ bun install promptfoo nie działa poprawnie w każdej sytuacji.

Uruchomienie skryptu: bun use_search

Rezultatem działania skryptu jest tablica zawierająca kilkanaście przykładowych testów dla promptu decydującego o tym, czy skorzystanie z wyszukiwarki jest potrzebne.

Pick domains

Uruchomienie skryptu: bun pick_domains

Rezultatem działania skryptu jest tablica zawierająca kilkanaście przykładowych testów dla promptu generującego zapytania do wyszukiwarki Internetowej, wskazując także odpowiednie domeny.

Rate

Uruchomienie skryptu: bun rate

Rezultatem działania skryptu jest tablica zawierająca kilkanaście przykładowych testów dla promptu oceniającego, czy odpowiedź modelu zawiera odpowiednie informacje.

Websearch

Przykład ten korzysta z Firecrawl do przeszukiwania Internetu oraz pobierania treści stron www. Konieczne jest więc uzupełnienie pliku .env wartości FIRECRAWL_API_KEY ustawionej na klucz API. (Firecrawl oferuje bezpłatny plan).

Uruchomienie serwera: bun websearch

Interakcja:

1
2
3

curl -X POST http://localhost:3000/api/chat \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role": "user", "content": "Search wiki for 'John Wick'"}]}'

Ważne: w pliku websearch/app.ts można zmienić listę domen, które są dopuszczalne do przeszukiwania i pobierania treści.

S01E02

Linear

Uruchomienie tego przykładu wymaga uzupełnienia pliku .env i wartości LINEAR_API_KEY oraz LINEAR_WEBHOOK_SECRET. Obie wartości można znaleźć w ustawieniach API. Dodatkowo Twój localhost musi być dostępny z poza Twojej sieci lokalnej, np. za pomocą ngrok. Publiczny adres URL należy także wskazać w panelu Linear w sekcji Webhooks, np.: https://<ngrok-url>/api/linear/watch-issue (pamiętaj o dodaniu właściwego endpointu do adresu).

WAŻNE: w pliku linear/prompts.ts znajduje się prompt w którym zostały opisane moje projekty w Linear. Aby skrypt działał poprawnie, musisz zmodyfikować ten prompt, tak aby zawierał identyfikatory oraz opisy Twoich projektów.

Listę projektów i ich identyfikatory możesz pobrać korzystając z endpointu /api/linear/projects.

Uruchomienie serwera: bun linear
Pobranie listy projektów: curl http://localhost:3000/api/linear/projects
Po dodaniu nowego wpisu w Twoim linearze, zostanie on automatycznie przypisany do projektu zgodnie z zasadami w promptach, o ile nie został przypisany przez Ciebie ręcznie.

Files

Uruchomienie serwera: bun files

Interakcja:

1
2
3

curl -X POST http://localhost:3000/api/chat \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role": "user", "content": "Hey there, what\'s up?"}], "conversation_id": "d7582176-bc52-4ef3-980a-047b868f9f49"}'

Przykład ten pokazuje mechanizm podejmowania decyzji o zapamiętywaniu informacji na podstawie kontekstu rozmowy. Dodatkowo w przypadku podania conversation_id w obiekcie żądania, do rozmowy zostaną wczytane wszystkie wiadomości dotyczące konkretnej rozmowy.

Wszystkie pliki zapisywane są w folderze files/context, a sam katalog można otworzyć w aplikacji Obsidian aby zobaczyć powiązania pomiędzy wspomnieniami.

S01E03

Langfuse

Ten przykład wymaga uzupełnienia pliku .env o wartości LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY oraz LANGFUSE_HOST. Można je uzyskać zakładając bezpłatne konto na Langfuse.

UWAGA: Aby uruchomić ten przykład, musisz w panelu Langfuse utworzyć nowy prompt o nazwie Answer, którego wartość możesz ustawić na np. ‘Odpowiadaj pisząc wyłącznie wielkimi literami’.

Uruchomienie serwera: bun langfuse

Interakcja:

1
2
3

curl -X POST http://localhost:3000/api/chat \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role": "user", "content": "Hey there, what\'s up?"}]}'

Po wykonaniu zapytania, zostanie ono automatycznie zalogowane do Langfuse, a wynik wyświetlony w panelu.

Tiktokenizer

Uruchomienie serwera: bun tiktokenizer

Interakcja:

1
2
3

curl -X POST http://localhost:3000/api/chat \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role": "user", "content": "Hey there, what\'s up?"}], "model": "gpt-4o"}'

Przykład ten pokazuje mechanizm liczenia tokenów w zapytaniach do modeli OpenAI (np. gpt-4o).

Max tokens

Przykład ten pokazuje jeden mechanizm pozwalający na kontynuowanie wypowiedzi modelu, pomimo osiągnięcia maksymalnej liczby tokenów wyjściowych (output tokens).

Uruchomienie serwera: bun max_tokens

Interakcja:

1
2
3

curl -X POST http://localhost:3000/api/chat \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role": "user", "content": "Write ten sentences about apples and put them in order."}]}'

Constitution

Przykład ten przedstawia mechanizm blokowania zapytań, które nie spełniają warunków określonych w prompcie /constitution/prompts.ts.

Uruchomienie serwera: bun constitution

Interakcja:

1
2
3

curl -X POST http://localhost:3000/api/chat \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role": "user", "content": "Hello!"}]}'

S01E04

Memory

Ten przykład po uruchomieniu tworzy katalog memories w którym zapisywane są pliki markdown, pełniące rolę pamięci modelu. Nie jest to przykład nadający się na produkcję, lecz przedstawia ogólne mechaniki pamięci długoterminowej, które będziemy rozwijać w dalszych lekcjach.

Uruchomienie serwera: bun memory
Interakcja:

1
2
3

 curl -X POST http://localhost:3000/api/chat \
   -H "Content-Type: application/json" \
   -d '{"messages": [{"role": "user", "content": "Hello!"}]}'

S01E05

External

Ten przykład zawiera standardową logikę interakcji z modelem, ale wymaga podania klucza API w nagłówku Authorization w formacie Bearer <klucz>. Wartość klucza zostaje wczytana z pliku .env jako PERSONAL_API_KEY. Dodatkowo zostały dodane mechanizmy ograniczania liczby zapytań, więc po kilku próbach ponowne wywołanie zapytania zwróci błąd 429.

Uruchomienie serwera: bun external

Interakcja:

1
2
3

curl -X POST http://localhost:3000/api/chat \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role": "user", "content": "Hello!"}]}'

Prompts

UWAGA: Aby uruchomić ten przykład konieczne jest nawiązanie połączenie z Langfuse poprzez uzupełnienie pliku .env o wartości LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY oraz LANGFUSE_HOST. Dodatkowo na Twoim koncie musisz utworzyć nowy prompt o nazwie Answer, którego wartość możesz ustawić na np. ‘Odpowiadaj pisząc wyłącznie wielkimi literami’, aby tylko sprawdzić działanie mechanizmu. Dodatkowo prompt “Answer” należy dodać w ustawieniu “Chat”, a nie “Text” (tryb można zmienić z pomocą zakładek w Langfuse)

Uruchomienie serwera: bun prompts

Interakcja:

1
2
3

curl -X POST http://localhost:3000/api/chat \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role": "user", "content": "Hello!"}]}'

Database

Ten przykład nie dotyczy bezpośrednio działania LLM, lecz przedstawia sposób organizacji informacji w bazie danych, takich jak konwersacje czy historia wiadomości.

Uruchomienie serwera: bun database

Interakcja:

1
2
3

curl -X POST http://localhost:3000/api/chat \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role": "user", "content": "Hello!"}]}'

Qdrant

Przykład ten przedstawia absolutnie podstawowe połączenie z bazą wektorową Qdrant. Jego zadaniem jest zapisywanie historii wiadomości, a następnie wyszukiwanie i wczytywanie do kontekstu rozmowy najbardziej podobnych wiadomości. Przykład ten będziemy rozbudowywać w dalszych lekcjach, łącząc się z Qdrant w bardziej złożonych konfiguracjach.

Uruchomienie serwera: bun qdrant

Interakcja:

1
2
3

curl -X POST http://localhost:3000/api/chat \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role": "user", "content": "Hello!"}]}'

S02E01

Audio

UWAGA: Ten przykład wymaga uruchomienia frontendu w folderze audio-frontend oraz backendu w folderze audio-backend. W związku z tym przykład trzeba uruchomić na własnym komputerze.

Uruchomienie frontendu: bun audio:dev
Uruchomienie backendu: bun audio
Interakcja: Otwórz w przeglądarce stronę http://localhost:5173

WAŻNE: Jakość działania tego przykładu zależy głównie od jakości mikrofonu oraz dźwięków otoczenia. Upewnij się więc, że jakość nagrania jest dobra i że nie ma zakłóceń uniemożliwiających wykrywanie końca wypowiedzi.

S02E02

Vision

Uruchomienie kodu: bun vision

Recognize

Uruchomienie kodu: bun recognize

Recognize-Pixtral

Do uruchomienia tego przykładu należy uzupełnić plik .env o wartość MISTRAL_API_KEY. Można go pobrać tutaj na Mistral.ai

Uruchomienie kodu: bun recognize_pixtral

S02E02

Vision

Uruchomienie kodu: bun vision
Interakcja: przykład wykonuje się automatycznie na pliku vision/lessons.png

Recognize

Uruchomienie kodu: bun recognize
Interakcja: przykład wykonuje się automatycznie na plikach z katalogu recognize/avatars

Recognize-Pixtral

Uruchomienie kodu: bun recognize_pixtral
Interakcja: przykład wykonuje się automatycznie na plikach z katalogu recognize_pixtral/avatars

S02E03

— brak przykładów —

S02E04

Captions

Uruchomienie kodu: bun captions
Interakcja: przykład wykonuje się automatycznie na pliku captions/article.md

Summary

Uruchomienie kodu: bun summary
Interakcja: skrypt wykonuje się automatycznie na pliku summary/article.md

Video

Do uruchomienia tego przykładu należy uzupełnić plik .env o wartość GOOGLE_AI_STUDIO_API_KEY, który można pobrać z Google AI Studio.

Uruchomienie kodu: bun video
Interakcja: przykład wykonuje się automatycznie na pliku video/test.mp3

Narration

UWAGA: Ten przykład może zużywać duże ilości kredytów na ElevenLabs, więc jeśli chcesz zobaczyć rezultat jego działania, to w katalogu narration znajdują się dwa przykładowe pliki audio, które możesz odtworzyć bez uruchamiania kodu.

Do uruchomienia tego przykładu należy uzupełnić plik .env o wartość GOOGLE_AI_STUDIO_API_KEY, który można pobrać z Google AI Studio oraz ELEVEN_LABS_API_KEY, który można pobrać z ElevenLabs.

Uruchomienie kodu: bun narration
Interakcja: przykład wykonuje się automatycznie na treści wiadomości użytkownika przekazanej w funkcji generateNarration w pliku narration/app.ts

S02E05

Read

Uruchomienie kodu: bun read
Interakcja: przykład wykonuje się automatycznie na pliku read/article.md i generuje plik audio w folderze read/summary.wav

Mindmap

Ten przykład wymaga uruchomienia frontendu w folderze audio-map-frontend oraz backendu w folderze audio-map. W związku z tym przykład trzeba uruchomić na własnym komputerze.

Uruchomienie frontendu: bun map:dev
Uruchomienie backendu: bun audio-map
Interakcja: Otwórz w przeglądarce stronę http://localhost:5173

Notes

Uruchomienie kodu: bun notes
Interakcja: przykład wykonuje się automatycznie na wiadomości wpisanej w treść pliku notes/app.ts (jest tam kilka przykładów innych wiadomości, które można podmienić).

S03E01

Text Splitter

Uruchomienie kodu: bun text-splitter
Interakcja: przykład wykonuje się automatycznie na plikach markdown z katalogu “text-splitter”

Unstructured

Uruchomienie kodu: bun unstructured
Interakcja: przykład wykonuje się automatycznie na pliku source.md z katalogu “unstructured”

S03E02

Embedding

Uruchomienie tego przykładu wymaga uzupełnienia pliku .env o wartości “QDRANT_URL” oraz “QDRANT_API_KEY”. Wartości te można znaleźć w panelu Qdrant po zalogowaniu na bezpłatne konto na stronie Qdrant Cloud.

Natomiast klucz API można pobrać w zakładce “Data Access Control”.

Uruchomienie kodu: bun embedding
Interakcja: przykład wykonuje się automatycznie na danych osadzonych w pliku embedding/app.ts

Rerank

Uruchomienie kodu: bun rerank
Interakcja: przykład wykonuje się automatycznie na danych osadzonych w pliku rerank/app.ts

Naive RAG

Uruchomienie kodu: bun naive-rag
Interakcja: przykład wykonuje się automatycznie na danych osadzonych w pliku naive-rag/app.ts

Better RAG

Uruchomienie kodu: bun better-rag
Interakcja: przykład wykonuje się automatycznie na danych osadzonych w pliku better-rag/app.ts

Semantic

Uruchomienie kodu: bun semantic
Interakcja: przykład wykonuje się automatycznie na danych osadzonych w pliku semantic/app.ts

S03E03

Algolia

Do uruchomienia tego przykładu konieczne jest uzupełnienie ALGOLIA_APP_ID oraz ALGOLIA_API_KEY w pliku .env. UWAGA: przy pierwszym uruchomieniu przykładu pojawi się błąd ale spowoduje to utworzenie indeksu w Algolia. Wówczas należy przejść do panelu Algolia i w zakładce “Facets” dodać nowy facet o nazwie author.

Uruchomienie kodu: bun algolia
Interakcja: przykład wykonuje się automatycznie na danych osadzonych w pliku algolia/app.ts

Sync

UWAGA: Do uruchomienia tego przykładu konieczne jest uzupełnienie ALGOLIA_APP_ID oraz ALGOLIA_API_KEY w pliku .env. Wymagane jest bezpłatne konto na Algolia.

Dodatkowo jeśli wyniki wyszukiwania nie są poprawnie zwracane, należy sprawdzić czy pole text zostało poprawnie ustawione w panelu Algolia jako searchableAttributes.

Uruchomienie kodu: bun sync
Interakcja: przykład wykonuje się automatycznie na danych osadzonych w pliku sync/app.ts

Hybrid

UWAGA: Do uruchomienia tego przykładu konieczne jest uzupełnienie QDRANT_URL oraz QDRANT_API_KEY w pliku .env. Konieczne jest także połączenie z Algolia podobnie jak w przypadku przykładu sync.

Uruchomienie kodu: bun hybrid
Interakcja: przykład wykonuje się automatycznie na danych osadzonych w pliku hybrid/app.ts

S03E05

Do uruchomienia tego przykładu konieczne jest połączenie z bazą Neo4j. Można ją zainstalować lokalnie, a następnie uzupełnić plik .env o wartości NEO4J_URI, NEO4J_USER oraz NEO4J_PASSWORD.

Neo4j-101

Uruchomienie kodu: bun neo4j-101
Interakcja: przykład wykonuje się automatycznie na danych osadzonych w pliku neo4j-101/app.ts

Neo4j

Uruchomienie kodu: bun neo4j
Interakcja: przykład wykonuje się automatycznie na danych osadzonych w pliku neo4j/app.ts