DEV Community: Hasan Ali

Perplexity.ai Nedir?

Hasan Ali — Mon, 19 Jan 2026 09:32:39 +0000

Perplexity.ai Nedir?

Google’a soru sorup 10 sekme açmaktan sıkıldıysan, bu yazı senin için.

Bu yazı dev.to okuyucuları için teknik ama keyifli bir dille hazırlanmıştır.

Bir düşün:
Bir şey merak ediyorsun. Google’a yazıyorsun. İlk link reklam, ikinci link SEO şişirmesi, üçüncü link 2017’den kalma… Sonra bir de ChatGPT’ye soruyorsun; güzel anlatıyor ama içinden bir ses diyor ki:

“Kaynağı ne bunun?” 🤨

İşte Perplexity.ai, tam bu noktada sahneye çıkıyor.

🚀 Perplexity.ai Kısaca Nedir?

Perplexity.ai, yapay zekâ destekli bir arama + cevap motorudur.

Ama klasik bir chatbot değildir:

Web’de gerçek zamanlı arama yapar
Birden fazla kaynağı tarar
Cevabı özetleyerek üretir
Ve en önemlisi: kaynak gösterir

Yani sana şunu der:

“Bu cevabı uydurmadım, bak buradan aldım.”

🤖 ChatGPT’den Farkı Ne?

Bu kısım çok karışır, netleştirelim.

ChatGPT

Genel bilgi + akıl yürütme
Uzun sohbetlerde güçlü
Kod yazma, içerik üretme konusunda çok iyi
Ama çoğu zaman:
- Web’e çıkmaz
- Kaynak vermez

Perplexity

Önce arar, sonra cevaplar
Araştırma odaklıdır
Cevapların altında:
- linkler
- site isimleri
- bazen birebir alıntılar bulunur

ChatGPT = Akıllı anlatıcı
Perplexity = Kaynaklı araştırmacı

🧠 Perplexity Perde Arkasında Nasıl Çalışır?

Basitleştirilmiş akış:

Soru sorulur
    ↓
Web araması yapılır
    ↓
İlgili içerikler seçilir
    ↓
LLM ile özetlenir
    ↓
Cevap + kaynaklar

Bu yüzden Perplexity hissiyatı şudur:

“Google ama okumayı senin yerine yapıyor.”

📚 Neden Adı "Perplexity"?

Kısa bir geek notu 🤓

Perplexity, dil modellerinde kullanılan bir metriktir
Modelin dili ne kadar iyi tahmin ettiğini ölçer

Ürün ismi olarak mesaj net:

“Kafanı karıştıran soruları sadeleştiriyoruz.”

✅ Hangi Sorularda Çok İyi?

Özellikle şu senaryolarda parlıyor:

“X nedir?”
“X ile Y arasındaki fark nedir?”
“2025’te en iyi … hangisi?”
“Bu konuda kim ne diyor?”
Teknik / akademik hızlı araştırmalar

Örnek:

"NestJS neden Fastify ile birlikte tercih ediliyor?"

Perplexity:

Birden fazla kaynağı tarar
Artı / eksi yönleri özetler
Altına referansları koyar

❌ Nerelerde İyi Değil?

Her araç her iş için uygun değil:

Uzun hikâye yazma
Yaratıcı metin üretimi
Derin sistem tasarımı
Uzun sohbet + kişisel hafıza

Bu alanlarda ChatGPT daha güçlü.

🔧 Aslında Perplexity Neyi Temsil Ediyor?

Teknik adıyla:

RAG (Retrieval Augmented Generation)

Yani:

Bilgiyi hafızada tutmak yerine
Her soruda gereken bilgiyi bulup
Onun üzerinden cevap üretmek

Bu yaklaşım, modern chatbot mimarilerinin temelidir.

🏗️ Chatbot Geliştirenler İçin Ders

❌ Mesaj geçmişini taşıma
✅ Gerekli veriyi çıkar ve gönder

Perplexity’nin yaptığı şey tam olarak budur.

🤝 ChatGPT + Perplexity Birlikte Kullanılır mı?

Kesinlikle evet.

Perplexity → araştır, kaynak bul, özetle
ChatGPT → yazıyı güzelleştir, kodu üret, mantığı kur

Birçok developer bu ikiliyi birlikte kullanıyor.

🧠 Akılda Kalması Gereken 3 Nokta

1️⃣ Perplexity = kaynaklı cevap
2️⃣ ChatGPT = üretim ve akıl yürütme
3️⃣ Modern AI sistemleri mesaj değil, bilgi taşır

🎯 Tek Cümlelik Final

Perplexity.ai, Google’da arayıp okuyacağın şeyi senin yerine okuyup, kaynaklarıyla birlikte özetleyen yapay zekâdır.

Suno API: Text-to-Music for Developers

Hasan Ali — Sun, 18 Jan 2026 10:23:09 +0000

What Is the Suno API?

Imagine describing a piece of music in plain English and receiving a complete audio track in return.

No instruments.

No samples.

No editing timelines.

Just text turning into music.

This is the core idea behind Suno, and the Suno API is how developers interact with this capability programmatically.

Suno in Plain Terms

Suno is an AI-powered music generation platform.

You describe the music you want using natural language — the mood, the tempo, the style — and Suno generates a full track based on that description. Depending on the mode, the output may include instrumental music, vocals, or both.

The API allows this process to happen outside of Suno’s user interface, making it accessible to software systems and automation tools.

What Exactly Is the Suno API?

The Suno API is a text-to-music interface.

From a high-level perspective, it works like this:

A system sends a text description of music
An AI model interprets that description
A music track is generated and returned as an audio asset

If you’re familiar with other generative AI systems, the concept should feel natural. It’s the same idea as text-to-image or text-to-speech — applied to music.

Why Developers Are Interested

AI music generation becomes especially powerful when combined with automation and scale.

Developers explore the Suno API for use cases such as:

Automatically generated background music
Personalized audio experiences
Creative tools driven by user input
Content pipelines that require unique, royalty-free music

In this context, music becomes another form of data that software can create, transform, and distribute.

Suno in Automation Workflows

Tools like n8n make Suno particularly interesting.

By connecting Suno to a workflow engine, music generation can be triggered by events:

A scheduled job
A user submission
A webhook or external system

The generated audio can then be forwarded, stored, or combined with other media — all without manual steps.

Suno effectively acts as a creative service inside a larger system.

Official vs Unofficial Access

When researching the Suno API, it’s important to note that not all references mean the same thing.

You’ll generally encounter:

Official access provided directly by Suno
Unofficial or community-built wrappers that interact with Suno indirectly

For anything beyond experimentation, understanding usage rights and limitations is essential.

Why This Matters

AI-generated music signals a broader shift in software development.

Creativity is becoming programmable.

Audio is joining text and images as a first-class AI output.

The Suno API sits at this intersection — where engineering meets creative generation — and points toward a future where software doesn’t just process information, but produces experiences.

Run PgBouncer with SCRAM Auth Using Docker

Hasan Ali — Sun, 18 Jan 2026 08:46:26 +0000

If you’re running PostgreSQL in production, PgBouncer is almost mandatory for efficient connection pooling.

This setup runs PgBouncer in Docker with SCRAM-SHA-256 authentication, using the exact password hash stored in Postgres — no weak MD5 hacks 🚫

🎯 Goal

⚡ Add connection pooling for PostgreSQL
🔐 Use SCRAM-SHA-256 authentication (secure by default)
🐳 Run PgBouncer in Docker
🌐 Connect services via Docker network
🔒 Expose PgBouncer locally only

🧾 Bash Script


bash
#!/usr/bin/env bash
set -euo pipefail

PGB_INI_PATH="/etc/pgbouncer/pgbouncer.ini"
PGB_USERLIST_PATH="/etc/pgbouncer/userlist.txt"

PG_HOST="postgres"
PG_PORT="5432"
PG_DB="postgres"
PG_USER="admin"

LISTEN_ADDR="0.0.0.0"
LISTEN_PORT="6432"

PGB_CONTAINER="pgbouncer"
PGB_IMAGE="edoburu/pgbouncer:v1.24.1-p1"

mkdir -p "$(dirname "$PGB_INI_PATH")" "$(dirname "$PGB_USERLIST_PATH")"

SCRAM_LINE="$(docker exec -i "$PG_HOST" psql -U "$PG_USER" -d "$PG_DB" -tA -c \
"SELECT '\"' || rolname || '\" \"' || rolpassword || '\"'
 FROM pg_authid
 WHERE rolname = '$PG_USER';" || true)"

if [[ -z "$SCRAM_LINE" ]]; then
  echo "ERROR: failed to fetch SCRAM hash from Postgres"
  exit 1
fi

if ! grep -q 'SCRAM-SHA-256' <<<"$SCRAM_LINE"; then
  echo "ERROR: Postgres password is not SCRAM-SHA-256"
  exit 1
fi

cat > "$PGB_INI_PATH" <<EOF
[databases]
$PG_DB = host=$PG_HOST port=$PG_PORT dbname=$PG_DB

[pgbouncer]
listen_addr = $LISTEN_ADDR
listen_port = $LISTEN_PORT
auth_type = scram-sha-256
auth_file = /etc/pgbouncer/userlist.txt
pool_mode = transaction
max_client_conn = 1000
default_pool_size = 20
reserve_pool_size = 5
reserve_pool_timeout = 5
log_connections = 1
log_disconnections = 1
log_pooler_errors = 1
ignore_startup_parameters = extra_float_digits
EOF

printf "%s\n" "$SCRAM_LINE" > "$PGB_USERLIST_PATH"

docker run -d \
  --name "$PGB_CONTAINER" \
  --network app-net \
  -p 127.0.0.1:${LISTEN_PORT}:${LISTEN_PORT} \
  -v "$(realpath "$PGB_INI_PATH"):/etc/pgbouncer/pgbouncer.ini:ro" \
  -v "$(realpath "$PGB_USERLIST_PATH"):/etc/pgbouncer/userlist.txt:ro" \
  "$PGB_IMAGE"

echo "PgBouncer is up 🚀"

Join a Server to Tailscale Using Docker

Hasan Ali — Sun, 18 Jan 2026 08:43:11 +0000

Managing private servers securely doesn’t have to involve VPN gateways or complex firewall rules.

With Tailscale, you can drop a server into your private mesh network in minutes — and yes, it works great in Docker 🐳✨

🎯 Goal

🕸️ Join a server to a Tailscale network
🐳 Run Tailscale inside Docker
🌐 Use host networking for full access
🔐 Authenticate using a Tailscale auth key

🧾 Bash Script


bash
#!/usr/bin/env bash
set -euo pipefail

CONTAINER="tailscale"
IMAGE="tailscale/tailscale:v1.90.9"
TS_AUTHKEY="tskey-XXXX"

docker run -d \
  --name "$CONTAINER" \
  --network host \
  --cap-add NET_ADMIN \
  --cap-add SYS_MODULE \
  -e TS_AUTHKEY="$TS_AUTHKEY" \
  "$IMAGE"

Run TimescaleDB with Docker in Minutes

Hasan Ali — Sun, 18 Jan 2026 08:41:07 +0000

Time-series data needs a database that’s fast, reliable, and production-ready.

That’s exactly what TimescaleDB (built on PostgreSQL) is great at 🐘⚡

In this post, we’ll spin up a TimescaleDB container using a clean Bash script.

🎯 Goal

🐳 Run TimescaleDB in Docker
🌐 Attach it to an existing Docker network (app-net)
💾 Persist data using volumes
🔁 Make restarts predictable

🧾 Bash Script


bash
#!/usr/bin/env bash
set -euo pipefail

DB="postgres"
USER="admin"
PASSWORD="PASSWORD"

CONTAINER="timescaledb"
IMAGE="timescale/timescaledb:2.24.0-pg18"

docker run -d \
  --name "$CONTAINER" \
  --network app-net \
  -e POSTGRES_PASSWORD="$PASSWORD" \
  -e POSTGRES_USER="$USER" \
  -e POSTGRES_DB="$DB" \
  -v timescale_data:/var/lib/postgresql/data \
  "$IMAGE"

echo "TimescaleDB is up 🚀 (image: $IMAGE)"

Secure Ubuntu Server Setup with Docker

Hasan Ali — Sun, 18 Jan 2026 08:36:32 +0000

Before running production workloads, it’s critical to secure your server and install the right foundations.

This Bash script prepares a fresh Ubuntu server with:

Docker + Docker Compose
UFW firewall
Fail2Ban (SSH protection)
Fish shell (optional but nice 🐟)

🎯 What This Script Does

🔄 Updates the system
🐳 Installs Docker & Docker Compose
🔐 Secures SSH with UFW + rate limiting
🚫 Protects against brute-force attacks using Fail2Ban
🧑‍💻 Improves shell experience with Fish

🧾 Bash Script


bash
#!/usr/bin/env bash
set -euo pipefail

sudo apt update && sudo apt upgrade -y

sudo apt install -y \
  apt-transport-https \
  ca-certificates \
  curl \
  gnupg \
  software-properties-common \
  ufw \
  fail2ban

curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
  | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] \
  https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" \
  | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin
sudo systemctl enable --now docker
sudo usermod -aG docker "$USER"

sudo apt install -y fish
chsh -s /usr/bin/fish

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow OpenSSH
sudo ufw limit OpenSSH
sudo ufw --force enable

sudo tee /etc/fail2ban/jail.local > /dev/null << 'EOF'
[DEFAULT]
bantime  = 1h
findtime = 10m
maxretry = 5
banaction = ufw

[sshd]
enabled = true
port = ssh
logpath = /var/log/auth.log
backend = systemd
EOF

sudo systemctl enable --now fail2ban

Run Cloudflare Tunnel with Docker in 5 Minutes

Hasan Ali — Sun, 18 Jan 2026 08:32:50 +0000

No public IP, no port forwarding, no reverse proxy headaches — but you still want to expose your service securely?

That’s exactly where Cloudflare Tunnel (cloudflared) shines ✨

In this post, we’ll quickly walk through a small but powerful Bash script that runs Cloudflare Tunnel using Docker.

🎯 Goal

🔒 Keep your server private
🌍 Let Cloudflare handle public traffic
🐳 Run everything in Docker
🎟️ Authenticate using a Tunnel Token

🧾 Bash Script


bash
#!/usr/bin/env bash
set -euo pipefail

CONTAINER="cloudflared"
IMAGE="cloudflare/cloudflared:2025.11.1"
TUNNEL_TOKEN="eyJhIjo..."

docker run -d \
  --name "$CONTAINER" \
  --restart unless-stopped \
  --network app-net \
  "$IMAGE" \
  tunnel --no-autoupdate run --token "$TUNNEL_TOKEN"