Przejdź do treści
Biblioteka skilli
Programowanie · Automatyzacja

groq-local-dev-loop

/groq-local-dev-loop

Konfiguruje lokalne środowisko pracy z Groq z hot reload, mockowaniem i testami, w tym podział na testy z mockami i na żywo, aby przyspieszyć iteracje.

Licencja
MIT
Ostatnia zmiana repozytorium
26.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
3
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
4
Przestarzałość

Brak sygnałów. Repozytorium zmienione 26.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Konfiguruje lokalne środowisko pracy z Groq z hot reload, mockowaniem i testami, w tym podział na testy z mockami i na żywo, aby przyspieszyć iteracje.

Wyzwalacze z opisu

groq dev setupgroq local developmentgroq dev environmentdevelop with groq
Oryginalny opis (EN)

Configure Groq local development with hot reload, mocking, and testing. Use when setting up a Groq development environment, configuring mocked vs live test workflows, or establishing a fast iteration cycle with Groq. Trigger with phrases like "groq dev setup", "groq local development", "groq dev environment", "develop with groq".

Jak działa

  1. Overview
  2. Prerequisites
  3. Authentication
  4. Instructions
  5. Output
  6. Error Handling
  7. Dev Tips
  8. Examples
  9. Resources
Sekcje z nagłówków SKILL.md, w oryginale · 108 linii, 699 słów
Podgląd SKILL.md
---
name: groq-local-dev-loop
description: 'Configure Groq local development with hot reload, mocking, and testing.

  Use when setting up a Groq development environment, configuring mocked vs live
  test workflows, or establishing a fast iteration cycle with Groq.

  Trigger with phrases like "groq dev setup", "groq local development",

  "groq dev environment", "develop with groq".

  '
allowed-tools: Read, Write, Edit, Bash(npm:*), Bash(pnpm:*)
version: 1.11.0
license: MIT
author: Jeremy Longshore <jeremy@intentsolutions.io>
tags:
- saas
- groq
- testing
- workflow
compatibility: Designed for Claude Code
---
# Groq Local Dev Loop

## Overview

Set up a fast, reproducible local development workflow for Groq. Groq's sub-second response times make it uniquely suited for tight dev loops -- you get LLM responses fast enough to iterate without context-switching. This skill scaffolds a project, a memoized client, model constants, and a two-tier test strategy (mocked unit tests + opt-in live integration tests). The lean skeleton lives here; the full code lives in [references/implementation.md](references/implementation.md) and [references/examples.md](references/examples.md).

## Prerequisites

- `groq-sdk` installed (`npm install groq-sdk`)
- `GROQ_API_KEY` set (free tier is fine for development)
- Node.js 18+ with tsx for TypeScript execution
- vitest for testing

## Authentication

The `groq-sdk` client reads `GROQ_API_KEY` from the environment automatically —
`new Groq()` and `getGroqClient()` both pick it up. Get a key at
[console.groq.com/keys](https://console.groq.com/keys), store it in a
git-ignored `.env.local`, and commit only `.env.example` as a template. Never
hardcode the key or commit `.env.local`.

## Instructions

Follow these seven steps in order. Steps 1-2 lay out the project; steps 3-4
centralize the client and model IDs; steps 5-6 establish the test tiers; step 7
templates the environment. Full code for each is in the reference files.

1. **Project structure** — create `src/groq/{client,models,completions}.ts`, `tests/`, and `.env.local` / `.env.example`.
2. **Package setup** — wire `dev` (tsx watch), `test` / `test:watch` (vitest), and `test:integration` scripts.
3. **Singleton client** — a lazily-memoized `getGroqClient()` that fails fast when `GROQ_API_KEY` is missing and a `resetClient()` for tests.
4. **Model constants** — a `MODELS` map with `DEV_MODEL` defaulting to `llama-3.1-8b-instant` to conserve dev quota.
5. **Unit tests with mocking** — `vi.mock("groq-sdk")` so unit tests run sub-second with zero API calls.
6. **Integration tests** — guard live-API tests behind `GROQ_INTEGRATION=1` with `describe.skipIf` so the default run stays offline.
7. **Environment template** — commit `.env.example`, git-ignore `.env.local`.

```typescript
// src/groq/client.ts -- lazily-memoized singleton
import Groq from "groq-sdk";

let _client: Groq | null = null;

export function getGroqClient(): Groq {
  if (!_client) {
    if (!process.env.GROQ_API_KEY) {
      throw new Error("GROQ_API_KEY not set. Copy .env.example to .env.local");
    }
    _client = new Groq({ apiKey: process.env.GROQ_API_KEY, maxRetries: 2, timeout: 30_000 });
  }
  return _client;
}
export function resetClient(): void { _client = null; }
```

See [references/implementation.md](references/implementation.md) for the full
project scaffold, package.json, model constants, and `.env.example`, and
[references/examples.md](references/examples.md) for the complete unit and
integration test files.

## Output

Applying the workflow produces:

- A scaffolded project with `src/groq/{client,models,completions}.ts` and a `tests/` directory.
- A **memoized `getGroqClient()`** that shares one configured client and throws an actionable error when `GROQ_API_KEY` is unset.
- A `MODELS` map + `DEV_MODEL` constant so dev runs on the cheap 8B model.
- A **two-tier test suite**: mocked unit tests (`npm run test:watch`, no API calls) and opt-in live tests (`npm run test:integration`, gated on `GROQ_INTEGRATION=1`).
- A `.env.example` template committed for the team, with real secrets in a git-ignored `.env.local`.

## Error Handling

| Error | Cause | Solution |
|-------|-------|----------|
| `GROQ_API_KEY not set` | Missing .env.local | Copy from .env.example |
| Test timeout | Live API call in unit test | Mock groq-sdk in unit tests |
| `429 rate_limit_exceeded` | Free tier RPM hit | Wait 60s or use `test:watch` with longer intervals |
| Port already in use | Another tsx watch running | Kill process or change port |

## Dev Tips

- Use `llama-3.1-8b-instant` during development (lowest quota usage, fastest).
- Set `temperature: 0` for deterministic outputs during debugging.
- Set `max_tokens` conservatively to avoid burning through free tier.
- Groq free tier: 30 RPM for 70B and 8B models -- plan your dev loops accordingly.

## Examples

Run the hot-reload app and the mocked unit-test watcher side by side, then
exercise the live API only when you opt in:

```bash
npm run dev                # tsx watch src/index.ts (hot reload)
npm run test:watch         # vitest --watch (mocked, no API calls)
npm run test:integration   # GROQ_INTEGRATION=1 vitest (live API)
```

For the complete mocked unit test (`vi.mock("groq-sdk")`) and the
`GROQ_INTEGRATION`-gated live integration test, see
[references/examples.md](references/examples.md).

## Resources

- [references/implementation.md](references/implementation.md) — full project scaffold, client, model constants, and env template.
- [references/examples.md](references/examples.md) — complete unit and integration test files.
- [groq-sdk npm](https://www.npmjs.com/package/groq-sdk)
- [Vitest Documentation](https://vitest.dev/)
- [tsx Documentation](https://github.com/privatenumber/tsx)
- For production-ready code patterns, see the `groq-sdk-patterns` skill.
Pliki w paczce (3)
  • SKILL.md 6 KB
  • references/examples.md 3 KB
  • references/implementation.md 3 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · jeremylongshore/tons-of-skills-marketplace100MIT
HelixDevelopment/agent100MIT

Identyczna treść występuje jeszcze w 1 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.

Migawka bazy z 13.11.2026 · wersja paczki 5b5f4f672fa2 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100perplexity-local-dev-loop
    Konfiguruje lokalne środowisko pracy z Perplexity z hot reload i testami, żeby przyspieszyć cykl iteracji.
  • 100hex-local-dev-loop
    Konfiguruje lokalne środowisko programistyczne Hex z hot reload i testami, aby przyspieszyć cykl iteracji.
  • 100framer-local-dev-loop
    Konfiguruje lokalne środowisko pracy z Framer z hot reload i testami, by przyspieszyć cykl iteracji.
  • 100exa-local-dev-loop
    Konfiguruje lokalne środowisko deweloperskie Exa z hot reload i testami, aby przyspieszyć cykl iteracji.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.