You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iggy.apache.org by pi...@apache.org on 2025/09/02 08:35:54 UTC

(iggy-website) branch main updated: Update docs by adding more docker images info, and connection string options

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 <pi...@gmail.com>
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?;