This is an automated email from the ASF dual-hosted git repository.
piotr pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/iggy-website.git
The following commit(s) were added to refs/heads/main by this push:
new 907e3e87a Update docs by adding more docker images info, and
connection string options
907e3e87a is described below
commit 907e3e87a4fa050582fcb264280e8704082ffd7a
Author: spetz <[email protected]>
AuthorDate: Tue Sep 2 10:35:48 2025 +0200
Update docs by adding more docker images info, and connection string options
---
docs/ai/mcp.md | 2 ++
docs/connectors/introduction.md | 2 ++
docs/introduction/about.md | 13 ++++++++-----
docs/sdk/rust/high_level_sdk.md | 33 +++++++++++++++++++++++++++++----
4 files changed, 41 insertions(+), 9 deletions(-)
diff --git a/docs/ai/mcp.md b/docs/ai/mcp.md
index 9e77a41d2..3f8974ac7 100644
--- a/docs/ai/mcp.md
+++ b/docs/ai/mcp.md
@@ -9,6 +9,8 @@ The [Model Context Protocol](https://modelcontextprotocol.io)
(MCP) is an open p
To start the MCP server, simply run `cargo run --bin iggy-mcp`.
+The [docker image](https://hub.docker.com/r/apache/iggy-mcp) is available, and
can be fetched via `docker pull apache/iggy-mcp`.
+
The minimal viable configuration requires at least the Iggy credentials, to
create the connection with the running Iggy server using TCP with which the MCP
server will communicate. You can choose between HTTP and STDIO transports (e.g.
for the local usage with tools such as [Claude
Desktop](https://claude.ai/download) choose `stdio`).
```toml
diff --git a/docs/connectors/introduction.md b/docs/connectors/introduction.md
index b01db0dfc..3f819c382 100644
--- a/docs/connectors/introduction.md
+++ b/docs/connectors/introduction.md
@@ -9,6 +9,8 @@ The highly performant and modular runtime for statically typed,
yet dynamically
**This is still WiP, and the runtime can be started only after compilation
from the source code (no installable package yet).**
+The [docker image](https://hub.docker.com/r/apache/iggy-connect) is available,
and can be fetched via `docker pull apache/iggy-connect`.
+
## Features
- **High Performance**: Utilizes Rust's performance characteristics to ensure
fast data ingestion and egress.
diff --git a/docs/introduction/about.md b/docs/introduction/about.md
index 0276bc28e..c97108b4e 100644
--- a/docs/introduction/about.md
+++ b/docs/introduction/about.md
@@ -44,8 +44,8 @@ The name is an abbreviation for the Italian Greyhound - small
yet extremely fast
- Additional features such as **server side message deduplication**
- **Multi-tenant** support via abstraction of **streams** which group
**topics**
- **TLS** support for all transport protocols (TCP, QUIC, HTTPS)
-- **[Connectors](/docs/connectors/introduction)** - sinks, sources and data
transformations based on the **custom Rust plugins**
-- **[Model Context Protocol](/docs/ai/mcp)** - provide context to LLM with
**MCP server**
+- **[Connectors](https://github.com/apache/iggy/tree/master/core/connectors)**
- sinks, sources and data transformations based on the **custom Rust plugins**
+- **[Model Context
Protocol](https://github.com/apache/iggy/tree/master/core/ai/mcp)** - provide
context to LLM with **MCP server**
- Optional server-side as well as client-side **data encryption** using
AES-256-GCM
- Optional metadata support in the form of **message headers**
- Optional **data backups and archiving** to disk or **S3** compatible cloud
storage (e.g. AWS S3)
@@ -59,7 +59,7 @@ The name is an abbreviation for the Italian Greyhound - small
yet extremely fast
- [Rust](https://crates.io/crates/iggy)
- [C#](https://www.nuget.org/packages/Apache.Iggy/)
-- Java
+- [Java](https://mvnrepository.com/artifact/org.apache.iggy/iggy-java-sdk)
- [Python](https://pypi.org/project/apache-iggy/)
- [Node.js (TypeScript)](https://www.npmjs.com/package/apache-iggy)
- [Go](https://pkg.go.dev/github.com/apache/iggy/foreign/go)
@@ -68,21 +68,24 @@ C++ and Elixir are work in progress.
## CLI
-The brand new, rich, interactive CLI is implemented under the `cli` project,
to provide the best developer experience. This is a great addition to the Web
UI, especially for all the developers who prefer using the console tools.
+The interactive CLI is implemented under the `cli` project, to provide the
best developer experience. This is a great addition to the Web UI, especially
for all the developers who prefer using the console tools.
Iggy CLI can be installed with `cargo install iggy-cli` and then simply
accessed by typing `iggy` in your terminal.
### Web UI
-There's a dedicated Web UI for the server, which allows managing the streams,
topics, partitions, browsing the messages and so on. This is an ongoing effort
to build a comprehensive dashboard for administrative purposes of the Iggy
server. Check the Web UI in the `/web` directory. The [docker image for Web
UI](https://hub.docker.com/r/iggyrs/iggy-web-ui) is available, and can be
fetched via `docker pull iggyrs/iggy-web-ui`.
+There's a dedicated Web UI for the server, which allows managing the streams,
topics, partitions, browsing the messages and so on. This is an ongoing effort
to build a comprehensive dashboard for administrative purposes of the Iggy
server. Check the Web UI in the `/web` directory.
+The [docker image](https://hub.docker.com/r/apache/iggy-web-ui) is available,
and can be fetched via `docker pull apache/iggy-web-ui`.
## Connectors
The highly performant and modular **[runtime](/docs/connectors/runtime)** for
statically typed, yet dynamically loaded connectors. Ingest the data from the
external sources and push it further to the Iggy streams, or fetch the data
from the Iggy streams and push it further to the external sources. **Create
your own Rust plugins** by simply implementing either the `Source` or `Sink`
trait and **build custom pipelines for the data processing**.
+The [docker image](https://hub.docker.com/r/apache/iggy-connect) is available,
and can be fetched via `docker pull apache/iggy-connect`.
## Model Context Protocol
The [Model Context Protocol](https://modelcontextprotocol.io) (MCP) is an open
protocol that standardizes how applications provide context to LLMs. The
**[Iggy MCP Server](/docs/ai/mcp)** is an implementation of the MCP protocol
for the message streaming infrastructure. It can be used to provide context to
LLMs in real-time, allowing for more accurate and relevant responses.
+The [docker image](https://hub.docker.com/r/apache/iggy-mcp) is available, and
can be fetched via `docker pull apache/iggy-mcp`.
### Docker
diff --git a/docs/sdk/rust/high_level_sdk.md b/docs/sdk/rust/high_level_sdk.md
index feb5dbd95..a2fb1010f 100644
--- a/docs/sdk/rust/high_level_sdk.md
+++ b/docs/sdk/rust/high_level_sdk.md
@@ -28,16 +28,41 @@ Which can be used to create the client like this:
let client =
IggyClient::from_connection_string("iggy://iggy:secret@localhost:3050")?;
```
-And here's the full example with its all optional parts:
+By default, the connection string will use TCP transport protocol, but you can
also specify the other one by including `+{protocol}` to the initial `iggy`
part, for example:
+```bash
+iggy+tcp://iggy:secret@localhost:3050
+iggy+quic://iggy:secret@localhost:3050
+iggy+http://iggy:secret@localhost:3050
+```
+
+And here's the full example of TCP connection string with its all optional
parts:
```bash
-iggy://iggy:secret@localhost:3050?tls=true&tls_domain=test.com&reconnection_retries=5&reconnection_interval=5s&reestablish_after=10s&heartbeat_interval=3s
+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
```
-By default, the connection string is parsed with the following options:
+By default, the **TCP** connection string is parsed with the following options:
- `tls` - whether to use the TLS connection or not (default: `false`)
- `tls_domain` - the domain to use for the TLS connection (default: `None`)
+- `tls_ca_file` - the path to the CA file to use for the TLS connection
(default: `None`)
+- `reconnection_retries` - the number of retries to establish the connection
(default: `unlimited`)
+- `reconnection_interval` - the interval between the reconnection attempts
(default: `1s`)
+- `reestablish_after` - the time to wait before reestablishing the connection
(default: `5s`)
+- `heartbeat_interval` - the interval between the heartbeat messages (default:
`5s`)
+- `nodelay` - whether to use the TCP_NODELAY option or not (default: `false`)
+
+For **QUIC**, the connection string is parsed with the following options:
+
+- `response_buffer_size` - the size of the response buffer (default:
`10_000_000`)
+- `max_concurrent_bidi_streams` - the maximum number of concurrent
bidirectional streams (default: `10000`)
+- `datagram_send_buffer_size` - the size of the datagram send buffer (default:
`100_000`)
+- `initial_mtu` - the initial MTU size (default: `1200`)
+- `send_window` - the size of the send window (default: `100_000`)
+- `receive_window` - the size of the receive window (default: `100_000`)
+- `keep_alive_interval` - the interval between the keep-alive messages
(default: `5000`)
+- `max_idle_timeout` - the maximum idle timeout (default: `10000`)
+- `validate_certificate` - whether to validate the server certificate or not
(default: `false`)
- `reconnection_retries` - the number of retries to establish the connection
(default: `unlimited`)
- `reconnection_interval` - the interval between the reconnection attempts
(default: `1s`)
- `reestablish_after` - the time to wait before reestablishing the connection
(default: `5s`)
@@ -97,7 +122,7 @@ let mut consumer = client
The code above will result in creating the consumer that will try to consume
the messages in batches of 1000 every 1 millisecond. The auto-commit is set to
commit the offset every second or when all the messages are consumed (fetched).
The polling strategy is set to `next` which means that the consumer will try to
consume the next available message from the partition currently assigned to the
consumer group (you can also invoke a regular `consumer()` builder if you do
not plan to use the [...]
-Finally, you can use the `next()` method to receive the messages from the
topic. The consumer doesn't need to be a mutable reference, as it's only
required during the initialization phase. Here's how you can consume the
messages:
+Finally, you can use the `next()` method to receive the messages from the
topic. The consumer doesn't need to be a mutable reference, as it's only
required during the initialization phase. The `init()` is used to ensure that
the consumer is ready to receive the messages by validating the existence of
the stream, topic, consumer group etc. Here's how you can consume the messages:
```rust
consumer.init().await?;
