# Installation

{% hint style="warning" %}
**This is the manual for older MicroStream versions (Version < 5.0).**

**The new documentation (Version >= 5.0) is located at:**

[https://docs.microstream.one/](https://docs.microstream.one/manual)
{% endhint %}

## Build Configuration

You can find the MicroStream libraries in our [Maven repository](https://repo.microstream.one/service/rest/repository/browse/maven-public/one/microstream/)

{% tabs %}
{% tab title="Maven" %}
{% code title="pom.xml" %}

```markup
<repositories>
    <repository>
        <id>microstream-releases</id>
        <url>https://repo.microstream.one/repository/maven-public</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>one.microstream</groupId>
        <artifactId>storage.embedded</artifactId>
        <version>04.01.00-MS-GA</version>
    </dependency>
</dependencies>
```

{% endcode %}
{% endtab %}

{% tab title="Gradle (Groovy)" %}
{% code title="build.gradle" %}

```groovy
repositories {
    maven {
        url 'https://repo.microstream.one/repository/maven-public'
    }
}

dependencies {
    implementation 'one.microstream:storage.embedded:04.01.00-MS-GA'
}
```

{% endcode %}

{% endtab %}

{% tab title="Gradle (Kotlin)" %}
{% code title="build.gradle.kts" %}

```kotlin
repositories {
    maven {
        url = uri("https://repo.microstream.one/repository/maven-public")
    }
}

dependencies {
    implementation("one.microstream:storage.embedded:04.01.00-MS-GA")
}
```

{% endcode %}

{% endtab %}

{% tab title="Scala SBT" %}
{% code title="build.sbt" %}

```scala
resolvers += "microstream-releases" at "https://repo.microstream.one/repository/maven-public"

libraryDependencies += "one.microstream" % "storage.embedded" % "04.01.00-MS-GA"
```

{% endcode %}

{% endtab %}

{% tab title="Apache Ivy" %}
{% code title="ivysettings.xml" %}

```markup
<resolvers>
    <ibiblio name="microstream-releases" 
        root="https://repo.microstream.one/repository/maven-public" 
        m2compatible="true" />
</resolvers>
```

{% endcode %}

{% code title="ivy.xml" %}

```markup
<dependencies>
    <dependency org="one.microstream" 
        name="storage.embedded" 
        rev="04.01.00-MS-GA" />
</dependencies>
```

{% endcode %}
{% endtab %}

{% tab title="Apache Buildr" %}
{% code title="Buildfile" %}

```ruby
repositories.remote << 'https://repo.microstream.one/repository/maven-public'

define 'my-app' do
  compile.with 'one.microstream:storage.embedded:04.01.00-MS-GA'
end
```

{% endcode %}

{% endtab %}

{% tab title="Bazel" %}
{% code title="WORKSPACE" %}

```python
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

RULES_JVM_EXTERNAL_TAG = "2.8"
RULES_JVM_EXTERNAL_SHA = "79c9850690d7614ecdb72d68394f994fef7534b292c4867ce5e7dec0aa7bdfad"

http_archive(
    name = "rules_jvm_external",
    strip_prefix = "rules_jvm_external-%s" % RULES_JVM_EXTERNAL_TAG,
    sha256 = RULES_JVM_EXTERNAL_SHA,
    url = "https://github.com/bazelbuild/rules_jvm_external/archive/%s.zip" % RULES_JVM_EXTERNAL_TAG,
)

load("@rules_jvm_external//:defs.bzl", "maven_install")

maven_install(
    artifacts = [
        "one.microstream:storage.embedded:04.01.00-MS-GA"
    ],
    repositories = [
        "https://repo.microstream.one/repository/maven-public"
    ],
)
```

{% endcode %}

{% code title="BUILD" %}

```python
maven_jar(
    name = "microstream",
    artifact = "one.microstream:storage.embedded:04.01.00-MS-GA"
)
```

{% endcode %}
{% endtab %}
{% endtabs %}

or in our P2 Update Site:

{% embed url="<https://repo.microstream.one/repository/update-site/04.01.00-MS-GA>" %}

## Modules

These are the different modules that make up MicroStream.

| ArtifactId                     | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| base                           | Collection of common utilities. Math, IO, Exceptions, Threads, String operations, and so on.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| cache                          | JSR-107 [JCache Provider](/cache/overview.md)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| cache.hibernate                | Hibernate region factory for jcache implementation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| communication                  | Top-level framework for sending and receiving object graphs between Java applications. Only data is transferred, no program code ("bytecode"). The other application may be programmed in any language as long as it adheres to the transmitted communication protocol. Usable directly in the program code of a Java application to communicate with other applications or processes. The concrete form of persistence is left open and delivered via a specific implementation as a plugin. Examples of specific persistent forms are binary data, CSV, XML, Json. |
| communication.binary           | Plugin framework for the top-level framework *communication* to convert the transferred object graphs to and from binary data.                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| filesystem.aws                 | File system implementations for AWS (S3, DynamoDB).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| filesystem.azure               | File system implementations for Azure Cloud (Azure Storage).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| filesystem.blobstore           | Base for all blob store file system implementations.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| filesystem.coherence           | File system implementation for Oracle Coherence.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| filesystem hazelcast           | File system implementation for Hazelcast.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| filesystem.jpa.hibernate       | Generic file system implementation for JPA / Hibernate.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| filesystem.kafka               | File system implementation for Apache Kafka.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| filesystem.mongodb             | File system implementation for MongoDB.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| filesystem.oraclecloud         | File system implementation for Oracle Cloud Services (Object Storage).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| filesystem.oraclenosql         | File system implementation for Oracle NoSQL.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| filesystem.redis               | File system implementation for Redis.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| filesystem.sql                 | File system implementation for SQL databases.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| persistence                    | <p>Base framework to convert a graph of java objects into a persistent form and back. Usable as a common, abstract base for all technologies implementing a specific persistent representation like binary data, CSV, XML or Json.</p><p>From a technical point of view, storage as well as serialization is a process that puts a graph of Java instances into a persistent form. The only difference is that network communication serialization discards this persistent form while a database solution preserves it.</p>                                         |
| persistence.binary             | Extension of the persistence base framework with a concrete implementation of the persistent form as binary data. This persistent form is superior to all text-based formats in storage and performance needs, making it the preferred method for storage and network serialization.                                                                                                                                                                                                                                                                                 |
| persistence.binary.jdk8        | [Specialized type handlers](/data-store/addendum/specialized-type-handlers.md#collections) for JDK 8 collection types.                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| storage                        | Basic framework to manage a graph of Java data persisted as binary data as a database. Can be used both to implement an embedded database solution (in the same process as the Java application) and a standalone or server-mode database solution (in a separate process). Other forms of persistence than binary data are deliberately not supported because they would not bring any noteworthy advantages but many disadvantages for the task.                                                                                                                   |
| storage.embedded               | Top-level framework for use in a Java application that adds an embedded database solution to its object graphs. Can be used directly in the program code of a Java application to comfortably and efficiently persist its data.                                                                                                                                                                                                                                                                                                                                      |
| storage.embedded.configuration | Layer with support for external configuration files (XML, INI) and convenience functionality to create foundations for the embedded storage.                                                                                                                                                                                                                                                                                                                                                                                                                         |
| storage.restadapter            | Adapter for low-level storage data externalization. Used by the [REST service](/data-store/rest-interface.md) to adapt to a MicroStream Storage.                                                                                                                                                                                                                                                                                                                                                                                                                     |
| storage.restclient             | Abstract REST client interface, which serves as a Java wrapper for the [REST API](/data-store/rest-interface/rest-api.md).                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| storage.restclient.app         | Executable [client app](/data-store/rest-interface/client-gui.md) with web user interface, which connects to a REST service.                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| storage.restclient.jersey      | REST client implementation which utilizes Jersey as a webservice framework.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| storage.restservice            | Abstract REST service interface, which uses the REST adapter to access low level storage data.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| storage.restservice.sparkjava  | REST service implementation which utilizes SparkJava and provides REST endpoints.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |

### Dependency Graph

![](/files/-MOfoUCBRbCfJDYIJgYQ)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://manual.docs.microstream.one/installation.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.