claudient 0.1.0

package/skills/ai-engineering/nl/claude-api.md

@@ -0,0 +1,250 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../claude-api.md).
+
+# Claude API Skill
+
+## Wanneer te activeren
+- Code schrijven die de Anthropic Claude API aanroept (Python of TypeScript SDK)
+- Prompt-caching, streaming of batchverwerking implementeren
+- Beheer van gesprekken met meerdere beurten ontwerpen
+- Het juiste Claude-model (Haiku, Sonnet, Opus) kiezen voor een taak
+- Toolgebruik / function calling toevoegen aan een Claude-integratie
+- Optimaliseren voor kosten of latentie in een productie-Claude-app
+
+## Wanneer NIET te gebruiken
+- OpenAI of andere provider-API's — andere SDK, andere patronen
+- Algemeen LLM-advies dat niet gerelateerd is aan de Anthropic API
+- Projecten die al LangChain of LlamaIndex-abstracties gebruiken — adresseer de abstractielaag in plaats daarvan
+
+## Instructies
+
+### Modelselectiegids
+| Model | Gebruik wanneer | Vermijd wanneer |
+|-------|----------|------------|
+| `claude-haiku-4-5-20251001` | Classificatie, extractie, routing, eenvoudige Q&A, hoog-volume goedkoop | Complexe redenering, meerstaps codegeneratie |
+| `claude-sonnet-4-6` | Algemeen gebruik: code, analyse, schrijven, agentische workflows | Token-beperkte budgetten op massale schaal |
+| `claude-opus-4-7` | Expertniveau-redenering, genuanceerd oordeel, complexe lange tekst | De meeste taken — Sonnet is meestal voldoende |
+
+### Basis berichtaanroep (Python)
+```python
+import anthropic
+
+client = anthropic.Anthropic()  # leest ANTHROPIC_API_KEY uit omgeving
+
+message = client.messages.create(
+    model="claude-sonnet-4-6",
+    max_tokens=1024,
+    system="You are a helpful assistant specialized in Python.",
+    messages=[
+        {"role": "user", "content": "Explain Python's GIL in 3 sentences."}
+    ]
+)
+print(message.content[0].text)
+```
+
+### Prompt-caching (kritisch voor kosten)
+Prompt-caching kan kosten met maximaal 90% verlagen voor herhaalde context. Cache stabiele inhoud (systeemprompts, grote documenten, few-shot-voorbeelden).
+
+```python
+message = client.messages.create(
+    model="claude-sonnet-4-6",
+    max_tokens=1024,
+    system=[
+        {
+            "type": "text",
+            "text": "You are a code review assistant. Here are our coding standards: ...",
+            "cache_control": {"type": "ephemeral"}  # Cache dit blok
+        }
+    ],
+    messages=[
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": large_document,
+                    "cache_control": {"type": "ephemeral"}  # Cache ook het document
+                },
+                {
+                    "type": "text",
+                    "text": "Summarize the key points."
+                }
+            ]
+        }
+    ]
+)
+# Controleer cachegebruik in respons
+print(message.usage.cache_read_input_tokens)   # tokens gelezen uit cache
+print(message.usage.cache_creation_input_tokens)  # tokens geschreven naar cache
+```
+
+Cacheregels:
+- Minimaal cacheerbaar blok: 1024 tokens (Sonnet/Opus), 2048 tokens (Haiku)
+- Cache-TTL: 5 minuten
+- Alleen het laatste `cache_control`-blok in een berichtarray telt — cachepunten zijn cumulatief
+
+### Streaming
+```python
+with client.messages.stream(
+    model="claude-sonnet-4-6",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": prompt}]
+) as stream:
+    for text in stream.text_stream:
+        print(text, end="", flush=True)
+
+# Of met events:
+with client.messages.stream(...) as stream:
+    for event in stream:
+        if event.type == "content_block_delta":
+            print(event.delta.text, end="")
+        elif event.type == "message_stop":
+            print()  # nieuwe regel wanneer klaar
+```
+
+### Toolgebruik
+```python
+tools = [
+    {
+        "name": "get_weather",
+        "description": "Get current weather for a city",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "city": {"type": "string", "description": "City name"},
+                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
+            },
+            "required": ["city"]
+        }
+    }
+]
+
+response = client.messages.create(
+    model="claude-sonnet-4-6",
+    max_tokens=1024,
+    tools=tools,
+    messages=[{"role": "user", "content": "What's the weather in Paris?"}]
+)
+
+# Controleer of Claude een tool wil gebruiken
+if response.stop_reason == "tool_use":
+    tool_use = next(b for b in response.content if b.type == "tool_use")
+    tool_result = call_tool(tool_use.name, tool_use.input)
+
+    # Ga door met gesprek met toolresultaat
+    follow_up = client.messages.create(
+        model="claude-sonnet-4-6",
+        max_tokens=1024,
+        tools=tools,
+        messages=[
+            {"role": "user", "content": "What's the weather in Paris?"},
+            {"role": "assistant", "content": response.content},
+            {
+                "role": "user",
+                "content": [{
+                    "type": "tool_result",
+                    "tool_use_id": tool_use.id,
+                    "content": json.dumps(tool_result)
+                }]
+            }
+        ]
+    )
+```
+
+### Gesprek met meerdere beurten
+```python
+class Conversation:
+    def __init__(self, system: str, model: str = "claude-sonnet-4-6"):
+        self.client = anthropic.Anthropic()
+        self.model = model
+        self.system = system
+        self.messages: list[dict] = []
+
+    def chat(self, user_message: str, max_tokens: int = 1024) -> str:
+        self.messages.append({"role": "user", "content": user_message})
+        response = self.client.messages.create(
+            model=self.model,
+            max_tokens=max_tokens,
+            system=self.system,
+            messages=self.messages,
+        )
+        assistant_message = response.content[0].text
+        self.messages.append({"role": "assistant", "content": assistant_message})
+        return assistant_message
+```
+
+### Batchverwerking
+```python
+from anthropic.types.message_create_params import MessageCreateParamsNonStreaming
+from anthropic.types.messages.batch_create_params import Request
+
+requests = [
+    Request(
+        custom_id=f"review-{i}",
+        params=MessageCreateParamsNonStreaming(
+            model="claude-haiku-4-5-20251001",
+            max_tokens=256,
+            messages=[{"role": "user", "content": f"Classify: {review}"}],
+        )
+    )
+    for i, review in enumerate(reviews)
+]
+
+batch = client.messages.batches.create(requests=requests)
+print(f"Batch ID: {batch.id}")
+
+# Poll voor resultaten (of gebruik webhooks)
+import time
+while True:
+    batch = client.messages.batches.retrieve(batch.id)
+    if batch.processing_status == "ended":
+        break
+    time.sleep(60)
+
+for result in client.messages.batches.results(batch.id):
+    print(result.custom_id, result.result.message.content[0].text)
+```
+
+### Foutafhandeling en herhaalpogingen
+```python
+from anthropic import APIStatusError, APITimeoutError, RateLimitError
+
+def call_with_retry(client, **kwargs, max_retries=3):
+    for attempt in range(max_retries):
+        try:
+            return client.messages.create(**kwargs)
+        except RateLimitError:
+            wait = 2 ** attempt
+            time.sleep(wait)
+        except APITimeoutError:
+            if attempt == max_retries - 1:
+                raise
+            time.sleep(1)
+        except APIStatusError as e:
+            if e.status_code >= 500 and attempt < max_retries - 1:
+                time.sleep(2 ** attempt)
+            else:
+                raise
+```
+
+### Kostenoptimalisatie-checklist
+- Gebruik Haiku voor classificatie, routing en eenvoudige extractietaken
+- Schakel prompt-caching in voor elke systeemprompt > 1024 tokens
+- Gebruik de batch API voor offline/async-workloads — 50% kostenvermindering
+- Stel `max_tokens` in op het minimum dat nodig is — je betaalt voor gegenereerde output-tokens
+- Cache grote documenten in het gebruikersbericht, niet alleen de systeemprompt
+- Monitor de verhouding `cache_read_input_tokens` vs `input_tokens` — streef naar >80% voor stabiele contexten
+
+## Voorbeeld
+
+**Gebruiker:** Bouw een Python-klasse die klantenservicetickets indeelt in categorieën met Claude, met prompt-caching voor de categorielijst en streaming voor de uitleg.
+
+**Verwachte output:**
+- `TicketClassifier`-klasse met `ANTHROPIC_API_KEY` uit omgeving
+- Systeemprompt met alle categorieën gecacht via `cache_control: ephemeral`
+- `classify(ticket_text)` → retourneert `{category: str, confidence: str}` geparseerd uit gestructureerde output
+- `classify_and_explain(ticket_text)` → streamt de uitleg naar stdout
+- Gebruikt `claude-haiku-4-5-20251001` voor classificatie (kostenefficiënt), `claude-sonnet-4-6` voor uitleg
+
+---
+
+> **Werk met ons:** Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten en B2B-oplossingen met ontwikkelaarsgemeenschappen. [uitbreiden.com](https://uitbreiden.com/)

package/skills/backend/dotnet/csharp.md

@@ -0,0 +1,304 @@
+# C#/.NET Skill
+
+## When to activate
+- Building a .NET Web API (minimal API or controller-based)
+- Setting up Entity Framework Core with migrations
+- Configuring the .NET dependency injection container
+- Writing background services with `IHostedService` or `BackgroundService`
+- Implementing middleware pipeline components
+- Writing LINQ queries and understanding deferred execution
+- Setting up async/await correctly in ASP.NET Core
+
+## When NOT to use
+- Node.js or Python services
+- .NET Framework (pre-.NET 5) legacy codebases — patterns differ
+- Blazor or MAUI frontend — different concerns
+- Unity game development — different runtime
+
+## Instructions
+
+### Project structure
+```
+MyApi/
+├── MyApi.sln
+├── src/
+│   └── MyApi/
+│       ├── Program.cs              # Entry point + DI container
+│       ├── appsettings.json
+│       ├── appsettings.Development.json
+│       ├── Controllers/            # Controller-based API
+│       ├── Endpoints/              # Minimal API extensions
+│       ├── Models/                 # EF Core entities
+│       ├── DTOs/                   # Request/response shapes
+│       ├── Services/               # Business logic interfaces + implementations
+│       ├── Data/
+│       │   └── AppDbContext.cs
+│       └── Middleware/
+└── tests/
+    └── MyApi.Tests/
+```
+
+### Program.cs — minimal API setup
+```csharp
+// Program.cs — .NET 6+ top-level statements + minimal API
+var builder = WebApplication.CreateBuilder(args);
+
+// Register services
+builder.Services.AddDbContext<AppDbContext>(options =>
+    options.UseNpgsql(builder.Configuration.GetConnectionString("Default")));
+
+builder.Services.AddScoped<IUserService, UserService>();
+builder.Services.AddControllers();
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen();
+
+var app = builder.Build();
+
+if (app.Environment.IsDevelopment())
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+app.UseHttpsRedirection();
+app.UseAuthentication();
+app.UseAuthorization();
+app.MapControllers();
+
+// Minimal API endpoints
+app.MapGroup("/api/v1").MapUserEndpoints();
+
+app.Run();
+```
+
+### EF Core entity + DbContext
+```csharp
+// Models/User.cs
+public class User
+{
+    public Guid Id { get; set; } = Guid.NewGuid();
+    public required string Email { get; set; }
+    public required string PasswordHash { get; set; }
+    public bool IsActive { get; set; } = true;
+    public DateTimeOffset CreatedAt { get; set; } = DateTimeOffset.UtcNow;
+
+    public ICollection<Post> Posts { get; set; } = [];
+}
+
+// Data/AppDbContext.cs
+public class AppDbContext(DbContextOptions<AppDbContext> options) : DbContext(options)
+{
+    public DbSet<User> Users => Set<User>();
+    public DbSet<Post> Posts => Set<Post>();
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.Entity<User>(e =>
+        {
+            e.HasIndex(u => u.Email).IsUnique();
+            e.Property(u => u.Email).HasMaxLength(320);
+        });
+    }
+}
+```
+
+### Dependency injection — services
+```csharp
+// Services/IUserService.cs
+public interface IUserService
+{
+    Task<UserDto> GetByIdAsync(Guid id, CancellationToken ct = default);
+    Task<UserDto> CreateAsync(CreateUserRequest request, CancellationToken ct = default);
+}
+
+// Services/UserService.cs
+public class UserService(AppDbContext db) : IUserService
+{
+    public async Task<UserDto> GetByIdAsync(Guid id, CancellationToken ct = default)
+    {
+        var user = await db.Users
+            .AsNoTracking()
+            .FirstOrDefaultAsync(u => u.Id == id, ct)
+            ?? throw new NotFoundException($"User {id} not found");
+
+        return new UserDto(user.Id, user.Email, user.CreatedAt);
+    }
+
+    public async Task<UserDto> CreateAsync(CreateUserRequest request, CancellationToken ct = default)
+    {
+        if (await db.Users.AnyAsync(u => u.Email == request.Email, ct))
+            throw new ConflictException("Email already in use");
+
+        var user = new User
+        {
+            Email = request.Email,
+            PasswordHash = BCrypt.Net.BCrypt.HashPassword(request.Password)
+        };
+        db.Users.Add(user);
+        await db.SaveChangesAsync(ct);
+        return new UserDto(user.Id, user.Email, user.CreatedAt);
+    }
+}
+```
+
+### Controller-based API
+```csharp
+[ApiController]
+[Route("api/v1/[controller]")]
+public class UsersController(IUserService userService) : ControllerBase
+{
+    [HttpGet("{id:guid}")]
+    [ProducesResponseType<UserDto>(StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetUser(Guid id, CancellationToken ct)
+    {
+        var user = await userService.GetByIdAsync(id, ct);
+        return Ok(user);
+    }
+
+    [HttpPost]
+    [ProducesResponseType<UserDto>(StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<IActionResult> CreateUser(
+        [FromBody] CreateUserRequest request,
+        CancellationToken ct)
+    {
+        var user = await userService.CreateAsync(request, ct);
+        return CreatedAtAction(nameof(GetUser), new { id = user.Id }, user);
+    }
+}
+```
+
+### Minimal API endpoints (extension method pattern)
+```csharp
+// Endpoints/UserEndpoints.cs
+public static class UserEndpoints
+{
+    public static RouteGroupBuilder MapUserEndpoints(this RouteGroupBuilder group)
+    {
+        var users = group.MapGroup("/users").WithTags("Users");
+
+        users.MapGet("/{id:guid}", async (Guid id, IUserService svc, CancellationToken ct) =>
+        {
+            var user = await svc.GetByIdAsync(id, ct);
+            return Results.Ok(user);
+        })
+        .WithName("GetUser")
+        .Produces<UserDto>();
+
+        return group;
+    }
+}
+```
+
+### Middleware
+```csharp
+// Middleware/RequestLoggingMiddleware.cs
+public class RequestLoggingMiddleware(RequestDelegate next, ILogger<RequestLoggingMiddleware> logger)
+{
+    public async Task InvokeAsync(HttpContext context)
+    {
+        var sw = Stopwatch.StartNew();
+        try
+        {
+            await next(context);
+        }
+        finally
+        {
+            sw.Stop();
+            logger.LogInformation(
+                "{Method} {Path} {StatusCode} in {Elapsed}ms",
+                context.Request.Method,
+                context.Request.Path,
+                context.Response.StatusCode,
+                sw.ElapsedMilliseconds);
+        }
+    }
+}
+
+// Register in Program.cs before other middleware:
+app.UseMiddleware<RequestLoggingMiddleware>();
+```
+
+### Background services
+```csharp
+// Services/CleanupService.cs
+public class CleanupService(IServiceProvider services, ILogger<CleanupService> logger)
+    : BackgroundService
+{
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            await DoCleanupAsync(stoppingToken);
+            await Task.Delay(TimeSpan.FromHours(1), stoppingToken);
+        }
+    }
+
+    private async Task DoCleanupAsync(CancellationToken ct)
+    {
+        // Use a new scope for each iteration — BackgroundService is singleton
+        using var scope = services.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
+        var cutoff = DateTimeOffset.UtcNow.AddDays(-30);
+        await db.Sessions.Where(s => s.ExpiresAt < cutoff).ExecuteDeleteAsync(ct);
+    }
+}
+
+// Register: builder.Services.AddHostedService<CleanupService>();
+```
+
+### LINQ best practices
+```csharp
+// Always use AsNoTracking() for read-only queries
+var users = await db.Users.AsNoTracking().Where(u => u.IsActive).ToListAsync(ct);
+
+// Select only needed columns — avoid loading full entities for projections
+var emails = await db.Users
+    .Where(u => u.IsActive)
+    .Select(u => u.Email)
+    .ToListAsync(ct);
+
+// Use ExecuteUpdateAsync/ExecuteDeleteAsync for bulk ops — skips loading entities
+await db.Users
+    .Where(u => !u.IsActive && u.CreatedAt < cutoff)
+    .ExecuteDeleteAsync(ct);
+
+// Avoid N+1: use Include() for related data
+var posts = await db.Posts
+    .Include(p => p.Author)
+    .Include(p => p.Tags)
+    .Where(p => p.Published)
+    .AsNoTracking()
+    .ToListAsync(ct);
+```
+
+### DTOs and records
+```csharp
+// Use records for immutable DTOs
+public record UserDto(Guid Id, string Email, DateTimeOffset CreatedAt);
+public record CreateUserRequest(
+    [property: Required, EmailAddress] string Email,
+    [property: Required, MinLength(8)] string Password
+);
+
+// Response types with problem details (built-in .NET)
+// Return Results.Problem() or throw exceptions caught by middleware
+```
+
+## Example
+
+**User:** Add a `BlogPost` resource to a .NET Web API: CRUD endpoints, EF Core entity, migrations, and a background job that publishes scheduled posts.
+
+**Expected output:**
+- `Models/BlogPost.cs` — entity with `Id`, `Title`, `Body`, `AuthorId` (FK to User), `PublishedAt` (nullable), `ScheduledFor` (nullable)
+- `DTOs/BlogPostDtos.cs` — `BlogPostDto` record, `CreateBlogPostRequest` record with `[Required]` validation
+- `Services/IBlogPostService.cs` + `BlogPostService.cs` — CRUD methods, `GetPendingScheduledAsync` for background job
+- `Controllers/BlogPostsController.cs` — all CRUD with proper status codes
+- `Services/PostPublisherService.cs` — `BackgroundService` that checks every minute and publishes due posts
+- EF Core migration: `dotnet ef migrations add AddBlogPosts`
+
+---
+
+> **Work with us:** Claudient is backed by [Uitbreiden](https://uitbreiden.com/) — we build AI products and B2B solutions with developer communities. [uitbreiden.com](https://uitbreiden.com/)