@wenathlan/saddle 1.8.17 → 2.0.2

package/docs/talks3/assistant-04.md

@@ -1,727 +0,0 @@
-# assistant
-
-[Thinking] The user wants me to continue with more searches and provide a detailed step-by-step guide. Let me do more searches on the specific topics they mentioned - ORMs converted to RAM, HuggingFace/Kaggle/ModelScope infrastructure, WASM memory emulators, npm CDN delivery, and more.
-
-[Thinking] Now let me do more searches on specific topics the user mentioned - Forgejo/Gitea/Codeberg CI/CD, Kaggle/ModelScope free compute, WASM memory emulation, and the specific use cases.
-
-[Thinking] Now I have enough research to compile a comprehensive step-by-step guide. Let me synthesize everything into a detailed implementation plan.
-
-[Thinking] Now let me compile the comprehensive guide. I need to be concise but thorough, covering all the aspects the user asked about.
-
-Vou fazer mais 10+ pesquisas específicas e compilar tudo em um guia ultra-detallado.
-
-Agora vou compilar tudo em um guia ultra-completo com todos os passos.
-
-Aqui está o guia completo compilado de 13 pesquisas realizadas:
-
-GUIA COMPLETO: Plataforma Sandbox com Infraestrutura Gratuita
-SUMÁRIO RÁPIDO
-
-
-
-Camada
-Solução
-Custo
-
-
-
-Storage → RAM
-zRAM + tmpfs + memfs
-Grátis
-
-
-Sandbox isolado
-gVisor (sem KVM) ou Firecracker (com KVM)
-Grátis
-
-
-Runner efêmero
-ephemerd ou ez-gh-actions
-Grátis (MIT)
-
-
-ORM in-memory
-Drizzle + SQLite WASM + PGLite
-Grátis
-
-
-CI/CD
-Forgejo Actions (self-hosted)
-Grátis
-
-
-AI/GPU
-HuggingFace + Kaggle + ModelScope
-Grátis (free tiers)
-
-
-CDN execução
-esm.sh + jsdelivr + use-m
-Grátis
-
-
-npm package
-Publicar lib própria
-Grátis
-
-
-
-PARTE 1: Memory Bridge (Storage → RAM)
-O que é
-Transformar armazenamento físico (disco) em memória RAM virtual usando zRAM, tmpfs e memfs.
-Passo 1: Setup zRAM no Linux
-#!/bin/bash
-# setup-zram.sh - Converte storage em RAM comprimida
-
-# Carregar módulo zRAM
-modprobe zram num_devices=2
-
-# Criar swap comprimido (até 2x mais memória)
-echo zstd > /sys/block/zram0/comp_algorithm
-echo $(($(grep -Po 'MemTotal:\s*\K\d+' /proc/meminfo)/2))KiB > /sys/block/zram0/disksize
-mkswap /dev/zram0
-swapon --priority 100 /dev/zram0
-
-# Criar filesystem em RAM para workspace
-echo zstd > /sys/block/zram1/comp_algorithm
-echo 4G > /sys/block/zram1/disksize
-mkfs.ext4 /dev/zram1
-mkdir -p /mnt/sandbox-ram
-mount /dev/zram1 /mnt/sandbox-ram
-chmod 1777 /mnt/sandbox-ram
-Passo 2: Setup tmpfs
-# Montar diretórios em RAM
-mount -t tmpfs -o size=4G,mode=1777 tmpfs /tmp/ramdisk
-mount -t tmpfs -o size=2G,mode=1777 tmpfs /var/cache/ram
-
-# Verificar
-df -h | grep -E 'tmpfs|zram'
-Passo 3: Biblioteca Node.js - Memory Bridge
-// src/memory-bridge.ts
-import { createFsFromVolume, Volume } from 'memfs';
-import { readFileSync, existsSync } from 'fs';
-import { join, dirname } from 'path';
-
-export class MemoryBridge {
-  private vol: Volume;
-  private fs: ReturnType<typeof createFsFromVolume>;
-
-  constructor(private maxRAM: string = '4G') {
-    this.vol = new Volume();
-    this.fs = createFsFromVolume(this.vol as any);
-  }
-
-  // Converte arquivo do disco para RAM
-  storageToRam(diskPath: string, ramPath: string): void {
-    if (!existsSync(diskPath)) throw new Error(`File not found: ${diskPath}`);
-    const data = readFileSync(diskPath);
-    this.vol.mkdirSync(dirname(ramPath), { recursive: true });
-    this.vol.writeFileSync(ramPath, data);
-  }
-
-  // Converte diretório inteiro para RAM
-  storageDirToRam(diskDir: string, ramDir: string): void {
-    const { readdirSync, statSync } = require('fs');
-    const files = readdirSync(diskDir);
-    for (const file of files) {
-      const fullPath = join(diskDir, file);
-      const ramPath = join(ramDir, file);
-      if (statSync(fullPath).isDirectory()) {
-        this.storageDirToRam(fullPath, ramPath);
-      } else {
-        this.storageToRam(fullPath, ramPath);
-      }
-    }
-  }
-
-  // Cria sandbox em memória
-  createSandbox(id: string): SandboxInstance {
-    const sandboxPath = `/sandbox/${id}`;
-    this.vol.mkdirSync(sandboxPath, { recursive: true });
-    return new SandboxInstance(this.vol, this.fs, sandboxPath, id);
-  }
-}
-
-export class SandboxInstance {
-  constructor(
-    private vol: Volume,
-    private fs: ReturnType<typeof createFsFromVolume>,
-    public path: string,
-    public id: string
-  ) {}
-
-  writeFileSync(name: string, content: string): void {
-    this.vol.writeFileSync(`${this.path}/${name}`, content);
-  }
-
-  readFileSync(name: string): Buffer {
-    return this.vol.readFileSync(`${this.path}/${name}`);
-  }
-
-  execute(code: string): string {
-    this.writeFileSync('index.js', code);
-    const { execSync } = require('child_process');
-    return execSync(`node -e "${code}"`, {
-      cwd: this.path,
-      timeout: 5000,
-      maxBuffer: 1024 * 1024 * 10
-    }).toString();
-  }
-}
-
-PARTE 2: Sandbox Isolado (gVisor / Firecracker)
-Passo 4: Instalar gVisor (sem necessidade de KVM)
-# Instalar gVisor runsc
-curl -fsSL https://gvisor.dev/archive.key | sudo gpg --dearmor -o /usr/share/keyrings/gvisor-archive-keyring.gpg
-echo "deb [signed-by=/usr/share/keyrings/gvisor-archive-keyring.gpg] https://storage.googleapis.com/gvisor/releases release main" | sudo tee /etc/apt/sources.list.d/gvisor.list
-sudo apt update && sudo apt install -y runsc
-
-# Configurar Docker para usar gVisor
-cat << EOF | sudo tee /etc/docker/daemon.json
-{
-  "runtimes": {
-    "runsc": {
-      "path": "/usr/bin/runsc"
-    }
-  }
-}
-EOF
-sudo systemctl restart docker
-
-# Testar sandbox
-docker run --rm --runtime=runsc ubuntu:22.04 cat /etc/os-release
-Passo 5: Script de Sandbox com Cota de Memória
-#!/bin/bash
-# create-sandbox.sh
-SANDBOX_ID=$1
-RAM_LIMIT=${2:-8g}
-CPU_LIMIT=${3:-4}
-
-docker run -d \
-  --name "sandbox-${SANDBOX_ID}" \
-  --runtime=runsc \
-  --memory="${RAM_LIMIT}" \
-  --cpus="${CPU_LIMIT}" \
-  --network=sandbox-net \
-  --read-only \
-  --tmpfs /tmp:size=2g \
-  -v /mnt/sandbox-ram/workspace-${SANDBOX_ID}:/workspace \
-  -e SANDBOX_ID="${SANDBOX_ID}" \
-  sandbox-base:latest
-
-PARTE 3: Runners Efêmeros (GitHub/Forgejo/Gitea)
-Passo 6: ephemerd (Multi-plataforma, MIT)
-# Baixar ephemerd
-# https://github.com/ephpm/ephemerd
-# Suporta: GitHub, Forgejo, Gitea, GitLab, Woodpecker
-
-# Configurar para Forgejo
-cat << 'EOF' > ~/.config/ephemerd/config.yaml
-provider: forgejo
-forgejo:
-  url: https://codeberg.org
-  token: ${FORGEJO_TOKEN}
-
-runner:
-  labels: ["self-hosted", "linux", "x64", "docker"]
-  image: "ghcr.io/actions/actions-runner:latest"
-  memory_mb: 8192
-  cpus: 4
-  count: 2
-
-sandbox:
-  type: docker
-  isolation: gvisor
-EOF
-
-# Iniciar
-ephemerd serve
-Passo 7: ez-gh-actions (Rust, VM-first)
-# Instalar
-cargo install --path .
-
-# Configurar
-ezgha init --target owner/repo
-ezgha doctor
-
-# Iniciar runner efêmero
-ezgha serve
-Passo 8: Forgejo Runner (Self-hosted)
-# Baixar Forgejo Runner
-wget https://code.forgejo.org/forgejo/forgejo-runner/releases/download/v12.10.2/forgejo-runner-12.10.2-linux-amd64
-chmod +x forgejo-runner-12.10.2-linux-amd64
-mv forgejo-runner-12.10.2-linux-amd64 /usr/local/bin/forgejo-runner
-
-# Criar config
-mkdir -p /etc/forgejo-runner
-cat << 'EOF' > /etc/forgejo-runner/config.yml
-runners:
-  - name: sandbox-runner
-    labels:
-      - "sandbox:docker://node:20-bookworm"
-      - "linux:docker://ubuntu:22.04"
-    container:
-      image: node:20-bookworm
-      options: |
-        --memory=8g
-        --cpus=4
-        --runtime=runsc
-      volumes:
-        - /mnt/sandbox-ram:/workspace
-EOF
-
-# Registrar no Forgejo/Codeberg
-forgejo-runner daemon --config /etc/forgejo-runner/config.yml
-
-PARTE 4: ORM In-Memory (Drizzle + SQLite WASM + PGLite)
-Passo 9: Drizzle com SQLite em Memória
-// src/db/memory-db.ts
-import { drizzle } from 'drizzle-orm/better-sqlite3';
-import Database from 'better-sqlite3';
-import { sql } from 'drizzle-orm';
-
-// SQLite 100% em memória (zero disco)
-const sqlite = new Database(':memory:');
-export const db = drizzle(sqlite);
-
-// Criar tabela
-db.run(sql`
-  CREATE TABLE sandboxes (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    name TEXT NOT NULL,
-    status TEXT DEFAULT 'created',
-    ram_mb INTEGER DEFAULT 4096,
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-  )
-`);
-
-// Drizzle com PGLite (Postgres em WASM)
-import { drizzle } from 'drizzle-orm/pglite';
-import { PGlite } from '@electric-sql/pglite';
-
-const client = new PGlite(); // In-memory Postgres
-export const pgDb = drizzle(client);
-
-// Drizzle com libSQL (SQLite com sync remoto)
-import { drizzle } from 'drizzle-orm/libsql';
-import { createClient } from '@libsql/client';
-
-const libsqlClient = createClient({
-  url: 'file:local.db',           // Local em memória
-  syncUrl: process.env.TURSO_URL, // Sync remoto opcional
-  authToken: process.env.TURSO_TOKEN,
-});
-export const libsqlDb = drizzle(libsqlClient);
-Passo 10: MySQL2 In-Memory (via SQLite bridge)
-// src/db/mysql-memory.ts
-import { drizzle } from 'drizzle-orm/mysql2';
-import mysql from 'mysql2/promise';
-import { createClient } from '@libsql/client';
-
-// Para MySQL-like queries em memória, usar SQLite como backend
-const sqlite = new (require('better-sqlite3'))(':memory:');
-const db = drizzle(sqlite);
-
-// OU: MySQL2 real com Docker container efêmero
-async function createMySQLContainer(id: string) {
-  const { execSync } = require('child_process');
-  execSync(`
-    docker run -d \
-      --name mysql-${id} \
-      --memory=1g \
-      --cpus=1 \
-      -e MYSQL_ROOT_PASSWORD=root \
-      -e MYSQL_DATABASE=sandbox \
-      mysql:8.0
-  `);
-
-  // Aguardar MySQL iniciar
-  await new Promise(r => setTimeout(r, 5000));
-
-  const connection = await mysql.createConnection({
-    host: '127.0.0.1',
-    user: 'root',
-    password: 'root',
-    database: 'sandbox'
-  });
-
-  return drizzle(connection);
-}
-
-PARTE 5: Pipelines nos Repositórios
-Passo 11: Forgejo/Codeberg Actions
-# .forgejo/workflows/sandbox.yml
-name: Sandbox Pipeline
-on:
-  push:
-    branches: [main]
-  workflow_dispatch:
-    inputs:
-      sandbox_config:
-        description: 'Sandbox config JSON'
-        required: true
-
-jobs:
-  create-sandbox:
-    runs-on: docker
-    container:
-      image: node:20-bookworm
-    steps:
-      - name: Checkout
-        uses: https://data.forgejo.org/actions/checkout@v4
-
-      - name: Setup Memory Bridge
-        run: |
-          apt-get update && apt-get install -y zram-tools
-          modprobe zram
-          zramctl /dev/zram0 --algorithm zstd --size 4G
-          mkswap /dev/zram0 && swapon /dev/zram0
-          mount -t tmpfs -o size=4G tmpfs /mnt/sandbox-ram
-
-      - name: Install Dependencies
-        run: |
-          npm ci
-          npm install memfs better-sqlite3 drizzle-orm
-
-      - name: Create In-Memory DB
-        run: |
-          node -e "
-            const Database = require('better-sqlite3');
-            const db = new Database(':memory:');
-            db.exec('CREATE TABLE sandboxes (id INTEGER PRIMARY KEY, name TEXT, status TEXT)');
-            db.exec(\"INSERT INTO sandboxes (name, status) VALUES ('sandbox-1', 'running')\");
-            console.log(db.prepare('SELECT * FROM sandboxes').all());
-          "
-
-      - name: Build Sandbox Image
-        run: docker build -t sandbox-${{ github.run_id }}:latest .
-
-      - name: Deploy Sandbox
-        run: |
-          docker run -d \
-            --name sandbox-${{ github.run_id }} \
-            --memory=8g --cpus=4 \
-            -v /mnt/sandbox-ram:/workspace \
-            sandbox-${{ github.run_id }}:latest
-Passo 12: GitHub Actions (grátis para público)
-# .github/workflows/sandbox-deploy.yml
-name: Deploy Sandbox
-on:
-  schedule:
-    - cron: '0 */6 * * *'  # A cada 6 horas
-  workflow_dispatch:
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup zRAM
-        run: |
-          sudo modprobe zram
-          sudo zramctl /dev/zram0 --algorithm zstd --size 4G
-          sudo mkswap /dev/zram0 && sudo swapon /dev/zram0
-
-      - name: Create Memory-Backed Sandbox
-        run: |
-          sudo mount -t tmpfs -o size=4G tmpfs /mnt/sandbox-ram
-          docker run -d \
-            --name sandbox-${{ github.run_id }} \
-            --memory=8g --cpus=4 \
-            -v /mnt/sandbox-ram:/workspace \
-            sandbox-base:latest
-
-      - name: Upload State to Artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: sandbox-state
-          path: /mnt/sandbox-ram/
-          retention-days: 1
-
-PARTE 6: CDN para Execução Instantânea
-Passo 13: esm.sh + use-m (Zero Install)
-<!-- index.html - Executar qualquer npm package sem instalar -->
-<script type="module">
-  // Carregar memfs do CDN
-  const { Volume } = await import('https://esm.sh/memfs@4.0.0');
-  const vol = new Volume();
-
-  // Carregar better-sqlite3 do CDN
-  const Database = (await import('https://esm.sh/better-sqlite3@11.0.0')).default;
-  const db = new Database(':memory:');
-
-  // Criar tabela
-  db.exec('CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)');
-  db.exec("INSERT INTO test (name) VALUES ('hello from RAM')");
-  console.log(db.prepare('SELECT * FROM test').all());
-</script>
-
-<!-- use-m: Dynamic package loader -->
-<script type="module">
-  async function loadUse(sources = [
-    'https://unpkg.com/use-m/src/use.js',
-    'https://cdn.jsdelivr.net/npm/use-m/src/use.js',
-    'https://esm.sh/use-m/src/use.js',
-  ]) {
-    for (const url of sources) {
-      try {
-        const response = await fetch(url);
-        if (!response.ok) throw new Error(`HTTP ${response.status}`);
-        const source = await response.text();
-        const exported = eval(source);
-        if (exported?.use) return exported.use;
-      } catch (e) { continue; }
-    }
-    throw new Error('Failed to load use-m');
-  }
-
-  const use = await loadUse();
-  const _ = await use('lodash@4.17.21');
-  console.log(_.chunk([1,2,3,4,5], 2)); // [[1,2],[3,4],[5]]
-</script>
-
-PARTE 7: Infraestrutura AI Gratuita
-Passo 14: HuggingFace Free Inference
-// src/ai/huggingface.ts
-import { InferenceClient } from '@huggingface/inference';
-
-const client = new InferenceClient(process.env.HF_TOKEN);
-
-// Text generation (grátis, rate-limited)
-const response = await client.textGeneration({
-  model: 'gpt2',
-  inputs: 'The future of AI is',
-  parameters: { max_new_tokens: 100 }
-});
-
-// Embeddings (grátis)
-const embeddings = await client.featureExtraction({
-  model: 'sentence-transformers/all-MiniLM-L6-v2',
-  inputs: 'This is a test sentence'
-});
-Passo 15: Kaggle GPU Gratuito
-// src/ai/kaggle-gpu.ts
-import { execSync } from 'child_process';
-
-// Kaggle: 30h/semana GPU T4 grátis, 30h/semana GPU P100
-// Usar via CLI
-const kaggleScript = `
-!pip install -q transformers torch
-from transformers import pipeline
-generator = pipeline('text-generation', model='gpt2', device=0)
-print(generator("Hello", max_length=50))
-`;
-
-// Push notebook para Kaggle
-execSync(`
-  kaggle kernels push \
-    --id myuser/my-kernel \
-    --type notebook \
-    --enable-gpu \
-    --source-file notebook.ipynb
-`);
-Passo 16: ModelScope Free (2000 chamadas/dia)
-// src/ai/modelscope.ts
-// OpenAI-compatible API: https://api-inference.modelscope.cn/v1
-
-import OpenAI from 'openai';
-
-const client = new OpenAI({
-  apiKey: process.env.MODELSCOPE_API_KEY,
-  baseURL: 'https://api-inference.modelscope.cn/v1'
-});
-
-// Qwen3.5, DeepSeek, GLM - tudo grátis
-const response = await client.chat.completions.create({
-  model: 'Qwen/Qwen3.5-27B',
-  messages: [{ role: 'user', content: 'Hello!' }]
-});
-
-PARTE 8: Projeto Principal (npm package)
-Passo 17: Estrutura do Projeto
-sandbox-memory-platform/
-├── package.json
-├── tsconfig.json
-├── src/
-│   ├── index.ts                 # Entry point
-│   ├── memory-bridge.ts         # Storage → RAM conversion
-│   ├── sandbox-runner.ts        # Runner management
-│   ├── orm-memory.ts            # Drizzle/Prisma in-memory
-│   ├── pipelines/
-│   │   ├── forgejo.ts           # Forgejo Actions integration
-│   │   ├── github.ts            # GitHub Actions integration
-│   │   └── gitlab.ts            # GitLab CI integration
-│   ├── ai/
-│   │   ├── huggingface.ts       # HuggingFace free inference
-│   │   ├── kaggle.ts            # Kaggle GPU free tier
-│   │   └── modelscope.ts        # ModelScope 2000 req/day
-│   └── cdn-loader.ts            # esm.sh/jsdelivr loader
-├── .github/workflows/
-│   └── sandbox.yml              # Self CI/CD
-├── .forgejo/workflows/
-│   └── sandbox.yml              # Forgejo CI/CD
-└── Dockerfile
-Passo 18: package.json
-{
-  "name": "@yourorg/sandbox-memory-platform",
-  "version": "1.0.0",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": "./dist/index.js",
-    "./memory-bridge": "./dist/memory-bridge.js",
-    "./orm-memory": "./dist/orm-memory.js",
-    "./cdn-loader": "./dist/cdn-loader.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsx watch src/index.ts",
-    "test": "vitest",
-    "sandbox:create": "tsx src/cli.ts create",
-    "sandbox:list": "tsx src/cli.ts list",
-    "sandbox:destroy": "tsx src/cli.ts destroy"
-  },
-  "dependencies": {
-    "memfs": "^4.0.0",
-    "better-sqlite3": "^11.0.0",
-    "drizzle-orm": "^0.28.0",
-    "@electric-sql/pglite": "^0.2.0",
-    "@libsql/client": "^0.6.0",
-    "dockerode": "^3.3.0",
-    "ws": "^8.16.0",
-    "@huggingface/inference": "^3.0.0",
-    "openai": "^4.0.0"
-  },
-  "peerDependencies": {
-    "drizzle-orm": "^0.28.0",
-    "mysql2": "^3.6.0",
-    "@prisma/client": "^5.0.0"
-  }
-}
-Passo 19: Dockerfile Multi-stage
-FROM node:20-bookworm AS builder
-WORKDIR /app
-COPY package*.json ./
-RUN npm ci
-COPY . .
-RUN npm run build
-
-FROM node:20-bookworm-slim AS runtime
-RUN apt-get update && apt-get install -y \
-    zram-tools \
-    docker.io \
-    && rm -rf /var/lib/apt/lists/*
-
-# Setup zRAM
-RUN modprobe zram && \
-    zramctl /dev/zram0 --algorithm zstd --size 4G && \
-    mkswap /dev/zram0 && swapon /dev/zram0
-
-WORKDIR /app
-COPY --from=builder /app/dist ./dist
-COPY --from=builder /app/node_modules ./node_modules
-COPY --from=builder /app/package.json ./
-
-EXPOSE 3000
-CMD ["node", "dist/index.js"]
-
-PARTE 9: Deploy Multi-Plataforma
-Passo 20: Deploy no Codeberg + HuggingFace Spaces
-# HuggingFace Spaces (grátis para demos)
-# .github/workflows/deploy-hf.yml
-name: Deploy to HuggingFace Spaces
-on:
-  push:
-    branches: [main]
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: huggingface/gh-actions-git-lfs-push@v1
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-
-RESUMO: O que Usar em Cada Cenário
-
-
-
-Cenário
-Solução
-Infraestrutura
-
-
-
-Converter disco → RAM
-zRAM + tmpfs + memfs
-Kernel Linux
-
-
-Sandbox isolado (sem KVM)
-gVisor runsc
-Docker
-
-
-Sandbox isolado (com KVM)
-Firecracker microVM
-KVM
-
-
-CI/CD gratuito (self-hosted)
-Forgejo Actions
-Codeberg/Gitea
-
-
-CI/CD gratuito (cloud)
-GitHub Actions (público)
-GitHub
-
-
-ORM em memória
-Drizzle + SQLite WASM
-Browser/Node.js
-
-
-Postgres em memória
-PGLite (WASM)
-Browser/Node.js
-
-
-AI inference grátis
-HuggingFace + ModelScope
-Free tiers
-
-
-GPU grátis
-Kaggle (30h/semana T4)
-Kaggle
-
-
-Execução sem install
-esm.sh + use-m
-CDN
-
-
-Runner efêmero
-ephemerd ou ez-gh-actions
-MIT
-
-
-
-MACETES IMPORTANTES
-
-zRAM: Comprime dados 2-3x, transforma 4GB em 8-12GB efetivos
-tmpfs: Filesystem 100% em RAM, zero I/O de disco
-memfs: Filesystem in-memory do Node.js, compatível com fs API
-SQLite :memory:: Banco de dados 100% em RAM, zero persistência
-PGLite: Postgres compilado para WASM, roda no browser
-esm.sh: Qualquer npm package via URL, sem instalar
-Forgejo: GitHub Actions compatível, self-hosted, sem limites
-Kaggle: 30h/semana GPU T4 grátis via notebook
-ModelScope: 2000 chamadas/dia grátis, API OpenAI-compatible
-HuggingFace: Inference grátis para modelos <10B params
-
-Quer que eu aprofunde alguma parte específica ou crie mais scripts?