Apache Iggy

https://iggy.apache.org/docs
Admin
Apache Iggy is a streaming platform and message broker designed for building real-time data...
Tokens:58,683
Snippets:427
Trust Score:10
Update:6 months ago
Show doc for...
Tokens:
Raw
### MCP Server - Getting Started

Source: https://iggy.apache.org/docs/ai/mcp

Instructions on how to start the MCP server using Cargo or Docker.

```APIDOC
## Getting Started with MCP Server

### Description
Instructions on how to start the MCP server locally or using a Docker image.

### Running Locally
To start the MCP server, use the following Cargo command:
```bash
CARGO_RUN --bin iggy-mcp
```

### Using Docker
Pull the official Docker image:
```bash
DOCKER PULL apache/iggy-mcp
```

### Configuration
The server requires Iggy credentials for connection. It supports `stdio` and `http` transports. A minimal configuration example is provided below:

```toml
transport = "stdio" # http or stdio are supported

[iggy]
address = "localhost:8090" # TCP address of the Iggy server
username = "iggy"
password = "iggy"
# token = "secret" # Personal Access Token (PAT) can be used instead of username and password
# consumer = "iggy-mcp" # Optional consumer name

[http] # Optional HTTP API configuration
address = "127.0.0.1:8082"
path = "/mcp"

[permissions]
create = true
read = true
update = true
delete = true
```

Configuration files can be in `toml`, `yaml`, or `json` format. Environment variables like `IGGY_MCP_CONFIG_PATH` and `IGGY_MCP_SECTION_NAME.KEY_NAME` can override settings.
```

--------------------------------

### Consumer Quick Start

Source: https://iggy.apache.org/docs/sdk/python/intro

A quick start guide for using the Iggy Python SDK as a consumer to receive messages.

```APIDOC
## Consumer Quick Start

### Description
This example demonstrates how to use the Iggy Python SDK to poll and receive messages from a stream and topic.

### Method
`GET` (implicitly through SDK methods)

### Endpoint
`iggy+tcp://iggy:iggy@localhost:8090` (connection string)

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
from apache_iggy import IggyClient, PollingStrategy, ReceiveMessage

STREAM_NAME = "sample-stream"
TOPIC_NAME = "sample-topic"
PARTITION_ID = 0

client = IggyClient.from_connection_string("iggy+tcp://iggy:iggy@localhost:8090")
await client.connect()

polled_messages = await client.poll_messages(
    stream=STREAM_NAME,
    topic=TOPIC_NAME,
    partition_id=PARTITION_ID,
    polling_strategy=PollingStrategy.Next(),
    count=10,
    auto_commit=True,
)

if polled_messages:
    for message in polled_messages:
        payload = message.payload().decode("utf-8")
        print(f"Offset: {message.offset()}, Payload: {payload}")
```

### Response
#### Success Response (200)
- **polled_messages** (list of `ReceiveMessage` objects) - A list of messages received from the specified partition.

#### Response Example
```
Offset: 0, Payload: message-0
Offset: 1, Payload: message-1
...
```
```

--------------------------------

### Producer Quick Start

Source: https://iggy.apache.org/docs/sdk/python/intro

A quick start guide for using the Iggy Python SDK as a producer to send messages.

```APIDOC
## Producer Quick Start

### Description
This example demonstrates how to use the Iggy Python SDK to send messages to a stream and topic.

### Method
`POST` (implicitly through SDK methods)

### Endpoint
`iggy+tcp://iggy:iggy@localhost:8090` (connection string)

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **messages** (list of `SendMessage` objects) - The messages to send.
- **stream** (string) - The name of the stream.
- **topic** (string) - The name of the topic.
- **partitioning** (integer) - The ID of the partition to send messages to.

### Request Example
```python
from apache_iggy import IggyClient
from apache_iggy import SendMessage as Message

STREAM_NAME = "sample-stream"
TOPIC_NAME = "sample-topic"
PARTITION_ID = 0

client = IggyClient.from_connection_string("iggy+tcp://iggy:iggy@localhost:8090")
await client.connect()

await client.create_stream(name=STREAM_NAME)
await client.create_topic(
    stream=STREAM_NAME,
    name=TOPIC_NAME,
    partitions_count=1,
    replication_factor=1,
)

messages = []
for i in range(10):
    payload = f"message-{i}"
    message = Message(payload)
    messages.append(message)

await client.send_messages(
    stream=STREAM_NAME,
    topic=TOPIC_NAME,
    partitioning=PARTITION_ID,
    messages=messages,
)
```

### Response
#### Success Response (200)
Messages are sent successfully. No explicit response body is detailed in the example.

#### Response Example
N/A
```

--------------------------------

### Python SDK Installation

Source: https://iggy.apache.org/docs/sdk/python/intro

Instructions on how to install the Iggy Python SDK using pip.

```APIDOC
## Python SDK Installation

### Description
Install the Iggy Python SDK using pip.

### Method
`pip install`

### Endpoint
N/A

### Parameters
None

### Request Example
```bash
pip install apache-iggy
```

### Response
N/A
```

--------------------------------

### Iggy Connection String Examples

Source: https://iggy.apache.org/docs/sdk/rust/high-level-sdk

Examples of connection strings for different transport protocols and a complex TCP connection string with optional parameters.

```text
iggy+tcp://iggy:secret@localhost:3050
iggy+quic://iggy:secret@localhost:3050
iggy+http://iggy:secret@localhost:3050
iggy://iggy:secret@localhost:3050?tls=true&tls_domain=test.com&reconnection_retries=5&reconnection_interval=5s&reestablish_after=10s&heartbeat_interval=3s&nodelay=true
```

--------------------------------

### Install Iggy Node.js SDK

Source: https://iggy.apache.org/docs/sdk/node/intro

Command to install the official Iggy client library for Node.js applications using npm.

```bash
npm install apache-iggy
```

--------------------------------

### Install Iggy C# SDK

Source: https://iggy.apache.org/docs/sdk/csharp/intro

Command to add the Apache.Iggy NuGet package to a .NET project.

```bash
dotnet add package Apache.Iggy
```

--------------------------------

### Install Iggy Python SDK

Source: https://iggy.apache.org/docs/sdk/python/intro

Installs the Iggy Python SDK using pip. This is the first step to using the SDK in your Python projects.

```bash
pip install apache-iggy
```

--------------------------------

### Go Producer Example for Iggy

Source: https://iggy.apache.org/docs/sdk/go/examples

Demonstrates how to create a producer client in Go to connect to an Iggy server, create streams and topics, and send messages. It requires the Iggy Go client library and assumes a running Iggy instance.

```Go
package main

import (
	"fmt"
	"time"

	"github.com/apache/iggy/foreign/go/client"
	"github.com/apache/iggy/foreign/go/client/tcp"
	iggcon "github.com/apache/iggy/foreign/go/contracts"
)

var (
	StreamId    = uint32(0)
	TopicId     = uint32(0)
	PartitionId = uint32(0)
)

func main() {
	// Create the client with TCP transport
	cli, err := client.NewIggyClient(
		client.WithTcp(tcp.WithServerAddress("127.0.0.1:8090")),
	)
	if err != nil {
		panic(err)
	}
	defer cli.Close()

	// Log in
	if _, err := cli.LoginUser("iggy", "iggy"); err != nil {
		panic(err)
	}

	// Create a stream
	if _, err := cli.CreateStream("sample-stream"); err != nil {
		panic(err)
	}

	// Create a topic with 1 partition, no compression, no expiry
	streamIdentifier, _ := iggcon.NewIdentifier(StreamId)
	if _, err := cli.CreateTopic(
		streamIdentifier,
		"sample-topic",
		1,                                  // partitions count
		iggcon.CompressionAlgorithmNone,
		iggcon.IggyExpiryNeverExpire,
		0,                                  // max topic size
		nil,                                // replication factor
	); err != nil {
		panic(err)
	}

	// Send messages in a loop
	partitioning := iggcon.PartitionId(PartitionId)
	for i := 1; i <= 10; i++ {
		payload := fmt.Sprintf("message-%d", i)
		message, _ := iggcon.NewIggyMessage([]byte(payload))

		streamIdentifier, _ := iggcon.NewIdentifier(StreamId)
		topicIdentifier, _ := iggcon.NewIdentifier(TopicId)
		if err := cli.SendMessages(
			streamIdentifier,
			topicIdentifier,
			partitioning,
			[]iggcon.IggyMessage{message},
		); err != nil {
			panic(err)
		}
		time.Sleep(500 * time.Millisecond)
	}
}
```

--------------------------------

### Run Apache Iggy MCP Server

Source: https://iggy.apache.org/docs/ai/mcp

Instructions on how to start the MCP server using Cargo and Docker. This is the primary method for launching the server.

```bash
cargo run --bin iggy-mcp
```

```bash
docker pull apache/iggy-mcp
```

--------------------------------

### Helm Chart Installation for Iggy

Source: https://iggy.apache.org/docs/server/docker

Basic command to install the Iggy Helm chart into a Kubernetes cluster, deploying the Iggy server with default configurations.

```bash
helm install iggy ./helm/charts/iggy
```

--------------------------------

### Install Iggy CLI using Cargo

Source: https://iggy.apache.org/docs/cli/start

Installs the Iggy CLI using the Cargo package manager. After installation, the `iggy` command can be used to access its functionalities.

```bash
cargo install iggy-cli
```

--------------------------------

### System Commands: Ping, Get Stats, Get Snapshot, Get Cluster Metadata, Get Me, Get Client, Get Clients

Source: https://iggy.apache.org/docs/server/schema

Provides definitions and command codes for various system-level operations in Iggy. This includes pinging the server, retrieving statistics, snapshots, cluster metadata, client information, and managing clients.

```rust
pub struct GetClient {
    pub client_id: u32
}
```

--------------------------------

### Perform Basic Iggy Operations

Source: https://iggy.apache.org/docs/sdk/rust/intro

A complete example showing how to create a stream, create a topic, send a message, and poll messages from the Iggy server.

```rust
use iggy::prelude::*; 

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = IggyClient::from_connection_string("iggy://iggy:iggy@localhost:8090")?;
    client.connect().await?;

    // Create stream and topic
    client.create_stream("my-stream").await?;
    client.create_topic(
        &"my-stream".try_into()?,
        "my-topic",
        2,
        CompressionAlgorithm::None,
        None,
        IggyExpiry::NeverExpire,
        MaxTopicSize::ServerDefault,
    ).await?;

    // Send a message
    let msg = IggyMessage::from_str("hello world")?;
    client.send_messages(
        &"my-stream".try_into()?,
        &"my-topic".try_into()?,
        &Partitioning::balanced(),
        &mut [msg],
    ).await?;

    // Poll messages
    let polled = client.poll_messages(
        &"my-stream".try_into()?,
        &"my-topic".try_into()?,
        Some(1),
        &Consumer::default(),
        &PollingStrategy::offset(0),
        10,
        false,
    ).await?;

    for message in &polled.messages {
        let payload = std::str::from_utf8(&message.payload)?;
        println!("Offset: {}, Payload: {}", message.header.offset, payload);
    }

    Ok(())
}
```

--------------------------------

### Go Consumer Example for Iggy

Source: https://iggy.apache.org/docs/sdk/go/examples

Demonstrates how to create a consumer client in Go to connect to an Iggy server and poll for messages from a specific stream and topic. It requires the Iggy Go client library and assumes a running Iggy instance with messages available.

```Go
package main

import (
	"fmt"
	"time"

	"github.com/apache/iggy/foreign/go/client"
	"github.com/apache/iggy/foreign/go/client/tcp"
	iggcon "github.com/apache/iggy/foreign/go/contracts"
)

var (
	StreamID    = uint32(0)
	TopicID     = uint32(0)
	PartitionID = uint32(0)
)

func main() {
	// Create the client with TCP transport
	cli, err := client.NewIggyClient(
		client.WithTcp(tcp.WithServerAddress("127.0.0.1:8090")),
	)
	if err != nil {
		panic(err)
	}
	defer cli.Close()

	// Log in
	if _, err := cli.LoginUser("iggy", "iggy"); err != nil {
		panic(err)
	}

	// Poll messages in a loop
	offset := uint64(0)
	consumer := iggcon.DefaultConsumer()

	for {
		streamIdentifier, _ := iggcon.NewIdentifier(StreamID)
		topicIdentifier, _ := iggcon.NewIdentifier(TopicID)
		pollMessages, err := cli.PollMessages(
			streamIdentifier,
			topicIdentifier,
			consumer,
			iggcon.OffsetPollingStrategy(offset),
			10,     // messages per batch
			false,  // auto-commit
			&PartitionID,
		)
		if err != nil {
			panic(err)
		}

		if len(pollMessages.Messages) == 0 {
			time.Sleep(500 * time.Millisecond)
			continue
		}

		offset += uint64(len(pollMessages.Messages))
		for _, message := range pollMessages.Messages {
			fmt.Printf("Offset: %d, Payload: %s\n",
				message.Header.Offset, string(message.Payload))
		}
	}
}
```

--------------------------------

### Iggy Consumer Application Entry Point

Source: https://iggy.apache.org/docs/introduction/getting-started

The main application setup for an Iggy consumer, including client initialization, user authentication, and triggering the consumption loop.

```rust
use iggy::prelude::*;
use std::error::Error;
use std::time::Duration;
use tokio::time::sleep;
use tracing::info;

const STREAM_NAME: &str = "sample-stream";
const TOPIC_NAME: &str = "sample-topic";
const PARTITION_ID: u32 = 1;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    tracing_subscriber::fmt::init();
    let client = IggyClient::default();
    client.connect().await?;
    client
        .login_user(DEFAULT_ROOT_USERNAME, DEFAULT_ROOT_PASSWORD)
        .await?;
    consume_messages(&client).await
}
```

--------------------------------

### Configure Iggy Connection Strings

Source: https://iggy.apache.org/docs/sdk/rust/intro

Examples of various connection string formats supported by the Iggy SDK, including different transport protocols and authentication methods.

```text
iggy://user:pass@host:port              (TCP, default)
iggy+tcp://user:pass@host:port          (TCP, explicit)
iggy+quic://user:pass@host:port         (QUIC)
iggy+http://user:pass@host:port         (HTTP)
iggy+ws://user:pass@host:port           (WebSocket)

iggy://iggy:iggy@my-server:8090?tls=true&tls_ca_file=/path/to/ca.crt
iggy://iggy:iggy@localhost:8090?reconnection_retries=unlimited&heartbeat_interval=5s
iggy://iggypat-your-token@localhost:8090
```

--------------------------------

### Receive Messages with Apache Iggy Node.js Consumer

Source: https://iggy.apache.org/docs/sdk/node/examples

This example shows how to establish a connection using the Apache Iggy Node.js SDK and poll for messages from a specific partition. It includes details on consumer configuration, polling strategies, and message processing.

```typescript
import { Client, PollingStrategy, Consumer } from 'apache-iggy';

const STREAM_ID = 1;
const TOPIC_ID = 1;
const PARTITION_ID = 0;

const client = new Client({
  transport: 'TCP',
  options: { port: 8090, host: '127.0.0.1' },
  credentials: { username: 'iggy', password: 'iggy' },
});

const polledMessages = await client.message.poll({
  streamId: STREAM_ID,
  topicId: TOPIC_ID,
  consumer: Consumer.Single,
  partitionId: PARTITION_ID,
  pollingStrategy: PollingStrategy.Offset(BigInt(0)),
  count: 10,
  autocommit: false,
});

for (const message of polledMessages.messages) {
  const payload = message.payload.toString('utf8');
  console.log(
    `Offset: ${message.headers.offset}, Payload: ${payload}`
  );
}

await client.destroy();
```

--------------------------------

### Advanced Producer Configuration with Builder

Source: https://iggy.apache.org/docs/sdk/rust/stream-builder

Provides a comprehensive example of configuring the Iggy Producer using the builder pattern, allowing detailed customization of various producer settings.

```APIDOC
## Advanced Producer Configuration with Builder

### Description
Configures the Iggy Producer using a builder pattern for detailed customization, including stream/topic details, partitioning, batching, intervals, and retry policies.

### Method
Builder Pattern

### Endpoint
N/A

### Parameters
#### Builder Methods
- **stream_id(Identifier)**: Set the stream identifier.
- **stream_name(String)**: Set the stream name.
- **topic_id(Identifier)**: Set the topic identifier.
- **topic_name(String)**: Set the topic name.
- **topic_partitions_count(u32)**: Set the number of partitions for the topic.
- **topic_replication_factor(i32)**: Set the replication factor for the topic.
- **batch_size(usize)**: Set the maximum number of messages to send in a batch.
- **send_interval(IggyDuration)**: Set the interval between sending messages.
- **partitioning(Partitioning)**: Specify how messages should be partitioned (Balanced, PartitionId, MessagesKey).
- **send_retries_count(u32)**: Set the maximum number of retries for sending messages.
- **send_retries_interval(IggyDuration)**: Set the interval between retries.

### Request Example
```rust
use iggy::error::IggyError;
use iggy::identifier::Identifier;
use iggy::messages::send_messages::{Partitioning};
use iggy::stream_builder::{IggyProducerConfig};
use iggy::utils::duration::IggyDuration;
use std::str::FromStr;

#[tokio::main]
async fn main() -> Result<(), IggyError> {
    let stream = "test_stream";
    let topic = "test_topic";

    let config = IggyProducerConfig::builder()
        .stream_id(stream.try_into()?)
        .stream_name(stream)
        .topic_id(topic.try_into()?)
        .topic_name(topic)
        .topic_partitions_count(10)
        .topic_replication_factor(2)
        .batch_size(100)
        .send_interval(IggyDuration::from_str("5ms").unwrap())
        .partitioning(Partitioning::balanced())
        .send_retries_count(3)
        .send_retries_interval(IggyDuration::new_from_secs(1))
        .build();
    Ok(())
}
```

### Response
N/A
```

--------------------------------

### Docker Compose for Iggy Server Deployment

Source: https://iggy.apache.org/docs/server/docker

Example docker-compose.yml file for running the Iggy server. It configures essential environment variables, port mappings, and volumes, and includes necessary capabilities like SYS_NICE and seccomp unconfined for io_uring and CPU affinity.

```yaml
iggy:
  image: apache/iggy:latest
  container_name: iggy
  restart: unless-stopped
  cap_add:
    - SYS_NICE
  security_opt:
    - seccomp:unconfined
  ulimits:
    memlock:
      soft: -1
      hard: -1
  environment:
    - IGGY_ROOT_USERNAME=iggy
    - IGGY_ROOT_PASSWORD=Secret123
    - IGGY_HTTP_ENABLED=true
    - IGGY_HTTP_ADDRESS=0.0.0.0:80
    - IGGY_TCP_ENABLED=true
    - IGGY_TCP_ADDRESS=0.0.0.0:3000
    - IGGY_QUIC_ENABLED=false
    - IGGY_WEBSOCKET_ENABLED=false
    - IGGY_HEARTBEAT_ENABLED=true
    - IGGY_HEARTBEAT_INTERVAL=5s
  ports:
    - "3010:80"
    - "5100:3000"
  networks:
    - iggy
  volumes:
    - iggy:/iggy/local_data

networks:
  iggy:

volumes:
  iggy:

```

--------------------------------

### Configure Iggy Producer with Advanced Builder

Source: https://iggy.apache.org/docs/sdk/rust/stream-builder

Provides a comprehensive example of using the IggyProducerConfig builder to define complex settings such as partitioning strategies, replication factors, retry policies, and batching intervals.

```rust
use iggy::error::IggyError;
use iggy::identifier::Identifier;
use iggy::messages::send_messages::{Partitioning};
use iggy::stream_builder::{IggyProducerConfig};
use iggy::utils::duration::IggyDuration;
use std::str::FromStr;

#[tokio::main]
async fn main() -> Result<(), IggyError> {
    let stream = "test_stream";
    let topic = "test_topic";

    let config = IggyProducerConfig::builder()
        .stream_id(stream.try_into()?)
        .stream_name(stream)
        .topic_id(topic.try_into()?)
        .topic_name(topic)
        .topic_partitions_count(10)
        .topic_replication_factor(2)
        .batch_size(100)
        .send_interval(IggyDuration::from_str("5ms").unwrap())
        .partitioning(Partitioning::balanced())
        .send_retries_count(3)
        .send_retries_interval(IggyDuration::new_from_secs(1))
        .build();
    Ok(())
}
```

--------------------------------

### Rust: Setup Logging with Tracing

Source: https://iggy.apache.org/docs/introduction/getting-started

This snippet demonstrates how to integrate logging into an Iggy application using the 'tracing' and 'tracing-subscriber' crates. It initializes the tracing subscriber for capturing logs, which is useful for debugging and monitoring. This should be called early in the main function.

```rust
use std::error::Error;
use iggy::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    tracing_subscriber::fmt::init();
    // ... rest of the client setup and connection code
    Ok(())
}
```

--------------------------------

### Iggy Server Configuration File

Source: https://iggy.apache.org/docs/server/configuration

A comprehensive example of the server configuration file (config.toml). It covers settings for consumer group rebalancing, message maintenance, HTTP server options, CORS security, and JWT authentication.

```toml
[consumer_group]
rebalancing_timeout = "30s"
rebalancing_check_interval = "5s"

[data_maintenance.messages]
cleaner_enabled = false
interval = "1 m"

[http]
enabled = true
address = "127.0.0.1:3000"
max_request_size = "2 MB"
web_ui = false

[http.cors]
enabled = true
allowed_methods = ["GET", "POST", "PUT", "DELETE"]
allowed_origins = ["*"]
allowed_headers = ["content-type", "authorization"]
exposed_headers = [""]
allow_credentials = false
allow_private_network = false

[http.jwt]
algorithm = "HS256"
issuer = "iggy.apache.org"
audience = "iggy.apache.org"
valid_issuers = ["iggy.apache.org"]
valid_audiences = ["iggy.apache.org"]
access_token_expiry = "1 h"
clock_skew = "5 s"
not_before = "0 s"
encoding_secret = "top_secret$iggy123$_jwt_HS256_key#!"
decoding_secret = "top_secret$iggy123$_jwt_HS256_key#!"
```

--------------------------------

### Send Messages with Apache Iggy Node.js Producer

Source: https://iggy.apache.org/docs/sdk/node/examples

This example demonstrates how to create a client, set up a stream and topic, and send multiple messages using the Apache Iggy Node.js SDK. It covers basic producer operations and message formatting.

```typescript
import { Client, Partitioning } from 'apache-iggy';

const client = new Client({
  transport: 'TCP',
  options: { port: 8090, host: '127.0.0.1', keepAlive: true },
  credentials: { username: 'iggy', password: 'iggy' },
});

const stream = await client.stream.create({ name: 'sample-stream' });
const topic = await client.topic.create({
  streamId: stream.id,
  name: 'sample-topic',
  partitionCount: 1,
  compressionAlgorithm: 1,
  replicationFactor: 1,
});

const messages = Array.from({ length: 10 }, (_, i) => ({
  id: i + 1,
  headers: [],
  payload: `message-${i + 1}`,
}));

await client.message.send({
  streamId: stream.id,
  topicId: topic.id,
  messages,
  partition: Partitioning.PartitionId(
    topic.partitions[0].id
  ),
});

await client.destroy();
```

--------------------------------

### Implement Basic Iggy Producer in C#

Source: https://iggy.apache.org/docs/sdk/csharp/examples

Demonstrates how to initialize an Iggy client, create streams and topics, and send a batch of messages to a specific partition.

```csharp
using System.Text;
using Apache.Iggy;
using Apache.Iggy.Configuration;
using Apache.Iggy.Enums;
using Apache.Iggy.Exceptions;
using Apache.Iggy.Factory;
using Apache.Iggy.Kinds;
using Apache.Iggy.Messages;

const string StreamName = "dev";
const string TopicName = "events";

var client = IggyClientFactory.CreateClient(new IggyClientConfigurator()
{
    BaseAddress = "127.0.0.1:8090",
    Protocol = Protocol.Tcp,
});

await client.ConnectAsync();
await client.LoginUser("iggy", "iggy");

try
{
    await client.CreateStreamAsync(StreamName);
}
catch (InvalidResponseException)
{
    Console.WriteLine("Stream already exists.");
}

try
{
    await client.CreateTopicAsync(
        Identifier.String(StreamName),
        TopicName,
        2,
        CompressionAlgorithm.None
    );
}
catch (InvalidResponseException)
{
    Console.WriteLine("Topic already exists.");
}

var partitioning = Partitioning.PartitionId(0);
for (int i = 0; i < 100; i++)
{
    var payload = Encoding.UTF8.GetBytes($"Event #{i}");
    var messages = new List<Message> { new Message(Guid.NewGuid(), payload) };
    await client.SendMessagesAsync(
        Identifier.String(StreamName),
        Identifier.String(TopicName),
        partitioning,
        messages
    );
}

Console.WriteLine("Sent 100 messages");
```

--------------------------------

### Initialize Iggy Client and Manage Resources in C++

Source: https://iggy.apache.org/docs/sdk/cpp/intro

Demonstrates how to establish a connection to an Iggy server using a connection string, authenticate, create a stream, and define a topic with specific partitions. This snippet requires the Iggy C++ FFI headers and proper memory management for the connection object.

```cpp
#include "lib.rs.h"

auto* client = iggy::ffi::new_connection("iggy://iggy:iggy@localhost:8090");
client->connect();
client->login_user("iggy", "iggy");

client->create_stream("my-stream");

iggy::ffi::Identifier stream_id;
stream_id.kind = "string";
stream_id.length = 9;
for (char c : std::string("my-stream"))
    stream_id.value.push_back(static_cast<uint8_t>(c));

client->create_topic(stream_id, "my-topic", 2);

iggy::ffi::delete_connection(client);
```

--------------------------------

### Initialize Iggy Client from Connection String

Source: https://iggy.apache.org/docs/sdk/rust/high-level-sdk

Demonstrates how to create an Iggy client instance using a standard connection string. This approach simplifies configuration by encapsulating connection details into a single URI.

```rust
let client = IggyClient::from_connection_string("iggy://iggy:secret@localhost:3050")?;
```

--------------------------------

### Configure Iggy Producer with Basic Settings

Source: https://iggy.apache.org/docs/sdk/rust/stream-builder

Demonstrates how to initialize an IggyProducerConfig using the from_stream_topic constructor for simple use cases with minimal configuration.

```rust
use iggy::stream_builder::{IggyProducerConfig};
use iggy::utils::duration::IggyDuration;
use std::str::FromStr;

let res = IggyProducerConfig::from_stream_topic(
            "test_stream",
            "test_topic",
            100,
            IggyDuration::from_str("5ms").unwrap(),
         ).unwrap();
```

--------------------------------

### GET /ui

Source: https://iggy.apache.org/docs/server/networking

Access the embedded Web UI for managing Iggy.

```APIDOC
## GET /ui

### Description
Serves the embedded Web UI for visual management of the Iggy server (requires iggy-web feature).

### Method
GET

### Endpoint
/ui

### Parameters
None

### Request Example
GET /ui

### Response
#### Success Response (200)
- **content** (text/html) - The Iggy Web UI dashboard
```

--------------------------------

### Implement Iggy Message Producer

Source: https://iggy.apache.org/docs/sdk/csharp/intro

Demonstrates how to initialize an Iggy client, create a stream and topic, and send a series of messages to a specific partition.

```csharp
using System.Text;
using Apache.Iggy;
using Apache.Iggy.Configuration;
using Apache.Iggy.Enums;
using Apache.Iggy.Factory;
using Apache.Iggy.Kinds;
using Apache.Iggy.Messages;

const string StreamName = "sample-stream";
const string TopicName = "sample-topic";

var client = IggyClientFactory.CreateClient(new IggyClientConfigurator()
{
    BaseAddress = "127.0.0.1:8090",
    Protocol = Protocol.Tcp,
});

await client.ConnectAsync();
await client.LoginUser("iggy", "iggy");

await client.CreateStreamAsync(StreamName);
await client.CreateTopicAsync(
    Identifier.String(StreamName),
    TopicName,
    1,
    CompressionAlgorithm.None
);

var partitioning = Partitioning.PartitionId(0);
for (int i = 0; i < 10; i++)
{
    var payload = Encoding.UTF8.GetBytes($"message-{i}");
    var messages = new List<Message> { new Message(Guid.NewGuid(), payload) };
    await client.SendMessagesAsync(
        Identifier.String(StreamName),
        Identifier.String(TopicName),
        partitioning,
        messages
    );
}
```

--------------------------------

### GET /metrics

Source: https://iggy.apache.org/docs/server/networking

Retrieves Prometheus metrics for the Iggy server instance.

```APIDOC
## GET /metrics

### Description
Returns the current Prometheus metrics for the server, useful for monitoring performance and health.

### Method
GET

### Endpoint
/metrics

### Parameters
None

### Request Example
GET /metrics

### Response
#### Success Response (200)
- **content** (text/plain) - Prometheus formatted metrics data

#### Response Example
# HELP iggy_messages_total Total number of messages
# TYPE iggy_messages_total counter
iggy_messages_total 1024
```

--------------------------------

### Topic Commands: Get Topic, Get Topics, Create Topic, Delete Topic

Source: https://iggy.apache.org/docs/server/schema

Outlines the commands for managing topics within Iggy streams. This covers retrieving topic details, creating new topics with various configurations (like compression and expiry), and deleting topics. Serialization details for each command are provided.

```rust
pub struct GetTopic {
    pub stream_id: Identifier,
    pub topic_id: Identifier
}

pub struct GetTopics {
    pub stream_id: Identifier
}

pub struct CreateTopic {
    pub stream_id: Identifier,
    pub partitions_count: u32,
    pub compression_algorithm: CompressionAlgorithm,
    pub message_expiry: IggyExpiry,
    pub max_topic_size: MaxTopicSize,
    pub replication_factor: Option<u8>,
    pub name: String,
}

pub enum CompressionAlgorithm {
    None,   // Value = 1
    Gzip,   // Value = 2
    Lz4,    // Value = 3
    Zstd,   // Value = 4
}

pub struct DeleteTopic {
    pub stream_id: Identifier,
    pub topic_id: Identifier
}
```

--------------------------------

### Get Users (Empty Payload) (Rust)

Source: https://iggy.apache.org/docs/server/schema

Represents an empty payload for retrieving all users.

```Rust
 
```

--------------------------------

### Connect to Iggy Server

Source: https://iggy.apache.org/docs/sdk/rust/intro

Demonstrates how to establish a connection to an Iggy server using either a connection string or the IggyClientBuilder for more granular configuration.

```rust
use iggy::prelude::*; 

// Connect with a connection string
let client = IggyClient::from_connection_string("iggy://iggy:iggy@localhost:8090")?;
client.connect().await?;

// Or use the builder
let client = IggyClientBuilder::new()
    .with_tcp()
    .with_server_address("localhost:8090".to_string())
    .build()?;
client.connect().await?;
client.login_user("iggy", "iggy").await?;
```

--------------------------------

### Get User (Rust)

Source: https://iggy.apache.org/docs/server/schema

Defines the structure for retrieving a specific user by their user ID.

```Rust
pub struct GetUser {
    pub user_id: Identifier
}
```

--------------------------------

### Basic Producer Configuration

Source: https://iggy.apache.org/docs/sdk/rust/stream-builder

Demonstrates how to configure the producer with a custom stream and topic name, along with batch size and send interval using the `from_stream_topic` constructor.

```APIDOC
## Basic Producer Configuration

### Description
Configures the producer with a custom stream and topic name, maximum batch size, and message send interval.

### Method
Constructor

### Endpoint
N/A

### Parameters
N/A

### Request Example
```rust
use iggy::stream_builder::{IggyProducerConfig};
use iggy::utils::duration::IggyDuration;
use std::str::FromStr;

let res = IggyProducerConfig::from_stream_topic(
            "test_stream",
            "test_topic",
            100,
            IggyDuration::from_str("5ms").unwrap(),
         ).unwrap();
```

### Response
N/A
```

--------------------------------

### GET /messages/poll

Source: https://iggy.apache.org/docs/sdk/csharp/examples

Polls messages from a specific stream and topic based on a consumer offset strategy.

```APIDOC
## GET /messages/poll

### Description
Retrieves a batch of messages from the Iggy broker using a polling strategy.

### Method
GET

### Endpoint
/messages/poll

### Parameters
#### Query Parameters
- **streamId** (string) - Required - The identifier of the stream.
- **topicId** (string) - Required - The identifier of the topic.
- **partitionId** (int) - Required - The partition to poll from.
- **consumer** (object) - Required - The consumer identifier.
- **strategy** (object) - Required - The polling strategy (e.g., offset).
- **count** (int) - Required - Number of messages to retrieve.

### Response
#### Success Response (200)
- **messages** (array) - List of message objects containing offset, header, and payload.

#### Response Example
{
  "messages": [
    {"header": {"offset": 0}, "payload": "RXZlbnQgIzA="}
  ]
}
```

--------------------------------

### Get Consumer Offset API

Source: https://iggy.apache.org/docs/server/schema

Retrieves the current offset for a consumer group in a specific topic partition.

```APIDOC
## Get Consumer Offset

### Description
Retrieves the current offset for a consumer group in a specific topic partition.

### Method
GET

### Endpoint
/websites/iggy_apache/consumers/{consumer_id}/offsets

### Parameters
#### Path Parameters
- **consumer_id** (Consumer) - Required - The ID of the consumer group.

#### Query Parameters
- **stream_id** (Identifier) - Required - The ID of the stream.
- **topic_id** (Identifier) - Required - The ID of the topic.
- **partition_id** (u32) - Optional - The ID of the partition. If not provided, the offset for all partitions might be returned.

### Request Example
```
GET /websites/iggy_apache/consumers/consumer_123/offsets?stream_id=stream_abc&topic_id=topic_xyz&partition_id=0
```

### Response
#### Success Response (200)
- **offset** (u64) - The current consumer offset.

#### Error Response (e.g., 400, 404)
- **code** (integer) - Error code.
- **message** (string) - Error message.
```

--------------------------------

### GET /message/poll

Source: https://iggy.apache.org/docs/sdk/node/intro

Polls messages from a specific stream, topic, and partition using a defined polling strategy.

```APIDOC
## GET /message/poll

### Description
Retrieves messages from a stream partition based on the provided polling strategy and consumer configuration.

### Method
GET

### Endpoint
client.message.poll

### Parameters
#### Request Body
- **streamId** (number) - Required - The ID of the stream.
- **topicId** (number) - Required - The ID of the topic.
- **consumer** (Consumer) - Required - The consumer type (e.g., Single).
- **partitionId** (number) - Required - The ID of the partition.
- **pollingStrategy** (PollingStrategy) - Required - The strategy used for polling (e.g., Offset).
- **count** (number) - Required - Number of messages to retrieve.
- **autocommit** (boolean) - Optional - Whether to automatically commit the offset.

### Request Example
{
  "streamId": 1,
  "topicId": 1,
  "consumer": "Consumer.Single",
  "partitionId": 1,
  "pollingStrategy": "PollingStrategy.Offset(0)",
  "count": 10,
  "autocommit": false
}
```

--------------------------------

### Stream Commands: Get Stream, Get Streams, Create Stream, Delete Stream, Update Stream, Purge Stream

Source: https://iggy.apache.org/docs/server/schema

Details the commands for managing streams within Iggy. This includes retrieving stream information, creating new streams, deleting existing ones, updating stream properties, and purging stream data. Serialization formats are specified for each command.

```rust
pub struct GetStream {
    pub stream_id: Identifier
}

pub struct CreateStream {
    pub name: String
}

pub struct DeleteStream {
    pub stream_id: Identifier
}

pub struct UpdateStream {
    pub stream_id: Identifier,
    pub name: String
}

pub struct PurgeStream {
    pub stream_id: Identifier
}
```

--------------------------------

### Install Iggy Rust SDK

Source: https://iggy.apache.org/docs/sdk/rust/intro

Add the Iggy crate to your Rust project using the cargo package manager.

```bash
cargo add iggy
```

--------------------------------

### Implement Basic Iggy Consumer in C#

Source: https://iggy.apache.org/docs/sdk/csharp/examples

Demonstrates how to connect to an Iggy server and poll messages from a specific stream and topic using a defined consumer offset.

```csharp
using System.Text;
using Apache.Iggy;
using Apache.Iggy.Configuration;
using Apache.Iggy.Contracts;
using Apache.Iggy.Enums;
using Apache.Iggy.Factory;
using Apache.Iggy.Kinds;

var client = IggyClientFactory.CreateClient(new IggyClientConfigurator()
{
    BaseAddress = "127.0.0.1:8090",
    Protocol = Protocol.Tcp,
});

await client.ConnectAsync();
await client.LoginUser("iggy", "iggy");

var consumer = Consumer.New(1);
var offset = 0ul;
uint messagesPerBatch = 100;

var polledMessages = await client.PollMessagesAsync(
    Identifier.String("dev"),
    Identifier.String("events"),
    0,
    consumer,
    PollingStrategy.Offset(offset),
    messagesPerBatch,
    false
);

foreach (var message in polledMessages.Messages)
{
    var payload = Encoding.UTF8.GetString(message.Payload);
    Console.WriteLine($"Offset: {message.Header.Offset}, Payload: {payload}");
}
```

--------------------------------

### Manage Personal Access Tokens via CLI

Source: https://iggy.apache.org/docs/server/security

Demonstrates how to create a new Personal Access Token (PAT) with a 7-day expiry and how to use that token to authenticate CLI requests.

```shell
# Create a PAT via CLI
iggy -u iggy -p secret pat create my-token 7d

# Use the PAT for authentication
iggy -t my-token-value stream list
```

--------------------------------

### Consumer Group Management API

Source: https://iggy.apache.org/docs/server/schema

APIs for managing consumer groups, including getting, creating, deleting, joining, and leaving groups.

```APIDOC
## GET /consumer/group

### Description
Retrieves a specific consumer group.

### Method
GET

### Endpoint
/consumer/group

### Parameters
#### Query Parameters
- **stream_id** (Identifier) - Required - The ID of the stream.
- **topic_id** (Identifier) - Required - The ID of the topic.
- **group_id** (Identifier) - Required - The ID of the consumer group.

### Response
#### Success Response (200)
- **Details** (object) - Information about the consumer group.

#### Response Example
```json
{
  "stream_id": "some_stream_id",
  "topic_id": "some_topic_id",
  "group_id": "some_group_id"
}
```
```

```APIDOC
## GET /consumer/groups

### Description
Retrieves a list of all consumer groups for a given stream and topic.

### Method
GET

### Endpoint
/consumer/groups

### Parameters
#### Query Parameters
- **stream_id** (Identifier) - Required - The ID of the stream.
- **topic_id** (Identifier) - Required - The ID of the topic.

### Response
#### Success Response (200)
- **groups** (array) - A list of consumer group IDs.

#### Response Example
```json
{
  "groups": ["group1", "group2"]
}
```
```

```APIDOC
## POST /consumer/group

### Description
Creates a new consumer group.

### Method
POST

### Endpoint
/consumer/group

### Parameters
#### Request Body
- **stream_id** (Identifier) - Required - The ID of the stream.
- **topic_id** (Identifier) - Required - The ID of the topic.
- **name** (String) - Required - The name of the consumer group (1-255 bytes).

### Request Example
```json
{
  "stream_id": "some_stream_id",
  "topic_id": "some_topic_id",
  "name": "my_new_group"
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message.

#### Response Example
```json
{
  "message": "Consumer group created successfully."
}
```
```

```APIDOC
## DELETE /consumer/group

### Description
Deletes a consumer group.

### Method
DELETE

### Endpoint
/consumer/group

### Parameters
#### Query Parameters
- **stream_id** (Identifier) - Required - The ID of the stream.
- **topic_id** (Identifier) - Required - The ID of the topic.
- **group_id** (Identifier) - Required - The ID of the consumer group to delete.

### Response
#### Success Response (200)
- **message** (string) - Confirmation message.

#### Response Example
```json
{
  "message": "Consumer group deleted successfully."
}
```
```

```APIDOC
## POST /consumer/group/join

### Description
Joins an existing consumer group.

### Method
POST

### Endpoint
/consumer/group/join

### Parameters
#### Request Body
- **stream_id** (Identifier) - Required - The ID of the stream.
- **topic_id** (Identifier) - Required - The ID of the topic.
- **group_id** (Identifier) - Required - The ID of the consumer group to join.

### Request Example
```json
{
  "stream_id": "some_stream_id",
  "topic_id": "some_topic_id",
  "group_id": "my_group"
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message.

#### Response Example
```json
{
  "message": "Successfully joined consumer group."
}
```
```

```APIDOC
## POST /consumer/group/leave

### Description
Leaves a consumer group.

### Method
POST

### Endpoint
/consumer/group/leave

### Parameters
#### Request Body
- **stream_id** (Identifier) - Required - The ID of the stream.
- **topic_id** (Identifier) - Required - The ID of the topic.
- **group_id** (Identifier) - Required - The ID of the consumer group to leave.

### Request Example
```json
{
  "stream_id": "some_stream_id",
  "topic_id": "some_topic_id",
  "group_id": "my_group"
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message.

#### Response Example
```json
{
  "message": "Successfully left consumer group."
}
```
```

--------------------------------

### Get Consumer Groups (Rust)

Source: https://iggy.apache.org/docs/server/schema

Defines the structure for retrieving multiple consumer groups. It requires stream ID and topic ID.

```Rust
pub struct GetConsumerGroups {
    pub stream_id: Identifier,
    pub topic_id: Identifier
}
```

--------------------------------

### Rust: Initialize Iggy Client and Connect

Source: https://iggy.apache.org/docs/introduction/getting-started

This snippet demonstrates how to initialize the Iggy client using default settings and establish a connection to the Iggy server. It utilizes the Tokio asynchronous runtime. Dependencies include the 'iggy' and 'tokio' crates.

```rust
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let client = iggy::client::IggyClient::default();
    client.connect().await?;
    Ok(())
}
```
Tokens:
Raw