fal.ai ile Hızlı AI Görsel Üretimi: FLUX ve Gerçek Zamanlı API Rehberi

Bu blogdaki tüm görseller fal.ai üzerinde üretiliyor. Peki fal.ai tam olarak nedir, nasıl çalışır ve kendi projelerinizde nasıl kullanırsınız? Bu yazıda sıfırdan başlayarak, API entegrasyonundan production pipeline’a kadar her şeyi anlatıyorum.

fal.ai’nin NVIDIA GPU altyapısı sayesinde queue beklemeden inference

1. Giriş: fal.ai Nedir?

fal.ai, AI görsel üretimi için gerçek zamanlı bir inference platformu. Geleneksel GPU çözümlerinden farkı, queue beklemeden saniyeler içinde sonuç almanızı sağlaması. NVIDIA GPU’lar üzerinde çalışan serverless altyapısı ile FLUX, Stable Diffusion, LoRA ve ControlNet gibi popüler modelleri anında çalıştırabilirsiniz.

Piyasadaki alternatiflerle karşılaştırdığımızda fal.ai’nin konumu net şekilde ortaya çıkıyor:

Neden fal.ai?

1. Queue yok — Tüm modeller serverless GPU’da anında çalışır, sıra beklemezsiniz
2. OpenAI-uyumlu API — Mevcut tooling ile sorunsuz entegrasyon
3. FLUX tam desteği — FLUX.1 Pro, FLUX.1 Schnell, FLUX.1 Dev, FLUX.1 Pro Ultra
4. LoRA ve ControlNet — Fine-tune ve conditioning desteği ile özel stiller
5. WebSocket streaming — Gerçek zamanlı output streaming ile ara sonuçları görme

2. Hızlı Başlangıç

API Key Alma

1. fal.ai/dashboard adresine gidin
2. GitHub hesabınızla kaydolun
3. Dashboard’dan API key oluşturun
4. Çevre değişkenine ekleyin:

export FAL_KEY="your-fal-api-key"

curl ile Test

En basit test — FLUX.1 Schnell ile görsel üretimi. Schnell, 4 adımda yüksek kaliteli sonuç veren en hızlı modeldir:

curl -X POST "https://fal.run/fal-ai/flux/schnell" \
  -H "Authorization: Key $FAL_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A serene mountain lake at sunset, digital art, vibrant colors",
    "image_size": "landscape_4_3",
    "num_inference_steps": 4
  }'

Cevap saniyeler içinde gelir:

{
  "images": [
    {
      "url": "https://fal.media/files/lion-mountain-lake-sunset.png",
      "width": 1024,
      "height": 768
    }
  ],
  "timings": {
    "inference": 0.342
  }
}

340 milisaniye — bu, gerçek zamanlı inference’nin ne demek olduğunu gösteriyor. Replicate’te aynı model minimum 2 saniye sürer.

3. Python SDK ile Entegrasyon

Kurulum

pip install fal-client

Temel Kullanım (Sync)

Senkron kullanım, tek seferlik görsel üretimleri için idealdir:

import fal_client

# Synchronous - basit, tek seferlik kullanım
result = fal_client.run(
    "fal-ai/flux/schnell",
    arguments={
        "prompt": "Modern minimalist office with natural light, architectural photography",
        "image_size": "landscape_4_3",
        "num_inference_steps": 4
    }
)

image_url = result["images"][0]["url"]
print(f"Görsel: {image_url}")
print(f"Süre: {result['timings']['inference']:.2f}s")

Çıktı:

Görsel: https://fal.media/files/modern-office-architectural.png
Süre: 0.38s

Async Kullanım (Paralel Üretim)

Asenkron kullanım, batch halinde birden fazla görsel üretmek için gereklidir. asyncio.gather ile paralel çalıştırarak toplam süreyi minimuma indirirsiniz:

import asyncio
import fal_client

async def generate_image(prompt: str) -> str:
    """Tek bir görsel asenkron üret."""
    result = await fal_client.run_async(
        "fal-ai/flux/schnell",
        arguments={
            "prompt": prompt,
            "image_size": "portrait_4_3",
            "num_inference_steps": 4
        }
    )
    return result["images"][0]["url"]

# Paralel üretim - 3 görsel aynı anda
async def generate_batch(prompts: list[str]) -> list[str]:
    tasks = [generate_image(p) for p in prompts]
    return await asyncio.gather(*tasks)

urls = asyncio.run(generate_batch([
    "Sunset over Bodrum castle, cinematic",
    "Yacht in turquoise water, aerial view",
    "Traditional Turkish breakfast, food photography"
]))

for i, url in enumerate(urls):
    print(f"Görsel {i+1}: {url}")

Çıktı:

Görsel 1: https://fal.media/files/bodrum-sunset-cinematic.png
Görsel 2: https://fal.media/files/yacht-aerial-turquoise.png
Görsel 3: https://fal.media/files/turkish-breakfast.png
Toplam süre: 0.92s (3 görsel paralel)

WebSocket ile Gerçek Zamanlı Streaming

fal.ai’nin en güçlü özelliklerinden biri — görsel üretilirken ara sonuçları streaming olarak alabilirsiniz. Bu, özellikle uzun süren Pro/Ultra modellerde kullanışlıdır:

import fal_client

# WebSocket ile gerçek zamanlı takip
for event in fal_client.run_iterator(
    "fal-ai/flux-pro/v1.1-ultra",
    arguments={
        "prompt": "Neo4j graph database visualization, glowing nodes, dark theme",
        "image_size": "landscape_4_3",
        "num_inference_steps": 25
    }
):
    if isinstance(event, fal_client.InProgress):
        print(f"İlerleme: {event.logs}" if event.logs else f"Adım: {event.step}")
    elif isinstance(event, fal_client.Queued):
        print(f"Kuyruk pozisyonu: {event.position}")
    elif isinstance(event, fal_client.Completed):
        print(f"✅ Görsel: {event.result['images'][0]['url']}")
        print(f"⏱ Süre: {event.result['timings']['inference']:.2f}s")

Çıktı:

Adım: 1/25
Adım: 5/25
Adım: 10/25
Adım: 15/25
Adım: 20/25
Adım: 25/25
✅ Görsel: https://fal.media/files/neo4j-graph-visualization.png
⏱ Süre: 4.87s

4. FLUX Modelleri Karşılaştırması

fal.ai’de kullanılabilen dört FLUX modeli var. Her birinin farklı hız, kalite ve fiyat profili var:

Ne Zaman Hangi Model?

• Blog görseli → Schnell — 4 adımda yeterli kalite, saniyede 3 görsel üretebilirsiniz
• Hero image → Dev — Detaylı kompozisyon için ideal. Bu blogdaki tüm hero görselleri Dev ile üretiliyor
• Portfolyo → Pro/Ultra — En yüksek kalite gerektiğinde, özellikle basılı materyaller için

Seed Kullanarak Tutarlı Sonuçlar

Aynı prompt ile farklı varyasyonlar almak için seed parametresini kullanabilirsiniz:

# Aynı prompt, farklı seed'ler
seeds = [42, 123, 456]
for seed in seeds:
    result = fal_client.run(
        "fal-ai/flux/dev",
        arguments={
            "prompt": "Modern office workspace, natural light",
            "image_size": "landscape_4_3",
            "num_inference_steps": 4,
            "seed": seed
        }
    )
    print(f"Seed {seed}: {result['images'][0]['url']}")

5. LoRA ile Özel Stil

Kendi LoRA modelinizi fal.ai’de kullanarak görsellere özel stiller uygulayabilirsiniz. LoRA (Low-Rank Adaptation), büyük bir modeli fine-tune etmeden belirli bir stili veya karakteri öğrenmenizi sağlar.

curl -X POST "https://fal.run/fal-ai/flux-lora" \
  -H "Authorization: Key $FAL_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "a portrait of <lora:moments-papercut-style> a person reading a book",
    "lora_url": "https://huggingface.co/ebartan/papercut-lora/resolve/main/papercut.safetensors",
    "image_size": "square_hd",
    "num_inference_steps": 4
  }'

Cevap:

{
  "images": [
    {
      "url": "https://fal.media/files/papercut-portrait-book.png",
      "width": 1024,
      "height": 1024
    }
  ],
  "timings": { "inference": 0.521 }
}

Python ile LoRA

result = fal_client.run(
    "fal-ai/flux-lora",
    arguments={
        "prompt": "A futuristic city skyline at night, <lora:cyberpunk-style>, neon lights",
        "lora_url": "https://storage.googleapis.com/fal-lora/cyberpunk.safetensors",
        "image_size": "landscape_4_3",
        "num_inference_steps": 4
    }
)

image_url = result["images"][0]["url"]
print(f"LoRA görsel: {image_url}")

Çıktı:

LoRA görsel: https://fal.media/files/cyberpunk-city-night-lora.png
Süre: 0.55s

6. ControlNet ile Kompozisyon Kontrolü

ControlNet, görselin yapısını kontrol etmenizi sağlar. Örneğin, bir karalamayı (scribble) alıp onu gerçekçi bir görsele dönüştürebilirsiniz:

import base64

# Karalama görselini base64'e çevir
with open("input_sketch.png", "rb") as f:
    sketch_b64 = base64.b64encode(f.read()).decode()

result = fal_client.run(
    "fal-ai/controlnet/scribble",
    arguments={
        "prompt": "A modern house in a forest, architectural rendering, photorealistic",
        "control_image": {
            "base64": sketch_b64,
            "media_type": "image/png"
        },
        "conditioning_scale": 0.8,  # 0.0-1.0, yüksek değer = kontrol daha baskın
        "image_size": "landscape_4_3"
    }
)

print(f"Görsel: {result['images'][0]['url']}")

Çıktı:

Görsel: https://fal.media/files/controlnet-house-forest.png
Süre: 1.23s
conditioning_scale=0.8 ile çizim %80 oranında korundu

ControlNet’in avantajı, görselin kompozisyonunu tamamen kontrol edebilmeniz. Scribble dışında canny (kenar tespiti), depth (derinlik haritası), pose (poz) gibi farklı ControlNet türleri de mevcut.

fal.ai’nin model seçim ve authentication arayüzü — tüm modeller tek dashboard’dan yönetilebilir

7. Production Pipeline: Otomatik Blog Görseli Üretimi

Bu blog için kullandığım pipeline — her yeni yazıda otomatik hero image üretimi yapan Python sınıfı:

import fal_client
import hashlib
from pathlib import Path
import requests

class BlogImageGenerator:
    """Blog görselleri için otomatik üretim pipeline'ı."""

    def __init__(self, fal_key: str):
        self.client = fal_client
        self.model = "fal-ai/flux/dev"
        self.output_dir = Path("src/assets/images")
        self.output_dir.mkdir(exist_ok=True)

    def generate_hero(
        self,
        title: str,
        excerpt: str,
        style: str = "Cinematic lighting, professional photography, 8K"
    ) -> str:
        """Blog başlığı ve özetinden hero image üret."""

        # Prompt oluştur
        prompt = f"{title}. {excerpt}. {style}"

        # FLUX.1 Dev ile görsel üret
        result = self.client.run(
            self.model,
            arguments={
                "prompt": prompt[:500],  # Token limit
                "image_size": "landscape_4_3",
                "num_inference_steps": 4,
                "guidance_scale": 3.5
            }
        )

        image_url = result["images"][0]["url"]
        return self._save_locally(image_url, title)

    def _save_locally(self, url: str, title: str) -> str:
        """Görseli indir ve assets klasörüne kaydet."""
        # Eşsiz dosya adı oluştur
        slug = hashlib.md5(title.encode()).hexdigest()[:12]
        filename = f"hero-{slug}.png"
        filepath = self.output_dir / filename

        # İndir ve kaydet
        response = requests.get(url)
        filepath.write_bytes(response.content)

        print(f"✅ Hero image kaydedildi: {filename}")
        print(f"   Prompt: {title[:60]}...")
        print(f"   Maliyet: ~$0.003")

        return f"~/assets/images/{filename}"

Kullanım

# Pipeline'ı çalıştır
generator = BlogImageGenerator(fal_key="fal-...")

image_path = generator.generate_hero(
    title="fal.ai ile Hızlı AI Görsel Üretimi",
    excerpt="FLUX modelleriyle gerçek zamanlı görsel üretimi rehberi"
)
print(f"Hero image: {image_path}")

Çıktı:

✅ Hero image kaydedildi: hero-fal-ai-pipeline.png
   Prompt: fal.ai ile Hızlı AI Görsel Üretimi...
   Maliyet: ~$0.003

Hero image: ~/assets/images/hero-fal-ai-pipeline.png

Bu pipeline sayesinde her yeni blog yazısında önce fal.ai’ye bir prompt gidiyor, çıkan görsel src/assets/images/ klasörüne düşüyor, sonra yazı yayına giriyor. Bu yazının hero görseli de aynı pipeline ile üretildi.

fal.ai, Hermes AI Agent ile entegre çalışarak otomatik görsel üretimi sağlar

8. Fiyatlandırma ve Optimizasyon

Gerçek Maliyet Hesaplama

Bu blog için aylık görsel üretim maliyeti:

Optimizasyon İpuçları

1. Schnell ile başlayın — 4 adımda prototip için yeterli kalite, maliyetin %60’ını düşürür
2. Seed kullanın — Aynı seed ile tutarlı sonuçlar alın, varyasyon için seed’i değiştirin
3. Negative prompt — İstenmeyen öğeleri engelleyerek kaliteyi artırın:

result = fal_client.run(
    "fal-ai/flux/dev",
    arguments={
        "prompt": "Modern office workspace, natural light, professional",
        "negative_prompt": "blurry, low quality, distorted, text, watermark, ugly, deformed",
        "image_size": "landscape_4_3",
        "num_inference_steps": 4
    }
)

4. Önbellekleme — Aynı prompt’u tekrar göndermeyin, seed ile varyasyon alarak önbellek kullanın
5. Batch üretim — Async kullanarak tek seferde birden fazla görsel çekin, connection overhead’ini azaltın
6. image_size optimizasyonu — İhtiyacınızdan büyük boyut istemeyin, square_hd çoğu kullanım için yeterli

Maliyet Karşılaştırması

*Sadece elektrik maliyeti, GPU kirası hariç **Rate limit ve kuyruk bekleme süreleri var

Kendi GPU’nuzu kiralamak büyük ölçekte daha ucuz olsa da, serverless çözümlerin bakım maliyeti (güncelleme, monitoring, scaling) neredeyse sıfır. Küçük ve orta ölçekli projeler için fal.ai en ekonomik seçenek.

9. Sonuç

fal.ai, AI görsel üretiminde queue beklemeden çalışan en pratik çözümlerden biri. FLUX modelleriyle saniyeler içinde blog görseli, sosyal medya postu veya prototip üretebilirsiniz.

Bu yazıda öğrendiklerimiz:

• ✅ fal.ai’nin Replicate ve HF Inference’a göre avantajları
• ✅ curl ile hızlı test, Python SDK ile sync/async entegrasyon
• ✅ FLUX modelleri (Schnell/Dev/Pro/Ultra) ve kullanım senaryoları
• ✅ LoRA ile özel stil, ControlNet ile kompozisyon kontrolü
• ✅ Production pipeline ile otomatik blog görseli üretimi
• ✅ Maliyet optimizasyonu ve en iyi pratikler

Bu blogdaki tüm görseller yukarıdaki pipeline ile üretiliyor — her yeni yazıda önce fal.ai’ye bir prompt gidiyor, çıkan görsel assets klasörüne düşüyor, sonra yazı yayına giriyor. Otomatikleştirilmiş bir AI görsel üretim hattı kurmak istiyorsanız, scripts/generate-fal-hero.py script’ini başlangıç noktası olarak kullanabilirsiniz.

Hero görseli: fal.ai + FLUX.1 Dev ile üretilmiştir

10. Kaynaklar

• fal.ai Resmi Sitesi
• fal.ai Dokümantasyon
• fal.ai API Referansı
• fal.ai GitHub
• FLUX.1 Model Card
• fal-client Python SDK
• LoRA Fine-Tuning Rehberi
• ControlNet Dokümantasyonu
• Fiyatlandırma Sayfası