Skip to main content

Setup of Extension Services

This section describes the required setup for various extension services that can be used to activate additional functionality in your Artemis instance.

EduTelligence Suite​

EduTelligence is a comprehensive suite of AI-powered microservices designed to enhance Artemis with intelligent features. Some of the AI-powered services that integrate with Artemis are now part of this unified suite.

Compatibility: EduTelligence maintains compatibility with different versions of Artemis. Please refer to the compatibility matrix to ensure you're using compatible versions for optimal integration and functionality.

Repository: github.com/ls1intum/edutelligence

EduTelligence / Iris​

Iris is the AI-powered virtual tutor integrated into Artemis. It is backed by Pyris, a FastAPI service from the EduTelligence suite. The Artemis-side configuration below is all that is required in this file; full Pyris deployment instructions live in the Iris admin documentation.

Configure Artemis​

In your application-artemis.yml (or your deployment-specific override), enable Iris and point it at your running Pyris instance:

artemis:
    iris:
        enabled: true
        url: https://pyris.your-domain.com # Or http://localhost:8000 for local development
        secret-token: your-shared-secret # Must match the token configured in Pyris

Optionally, configure per-user rate limiting:

artemis:
    iris:
        ratelimit:
            default-limit: 100 # Max requests per user (-1 for unlimited)
            default-timeframe-hours: 3 # Time window for the limit

Deploying Pyris and managing Iris​

For Pyris deployment and configuration, refer to the Iris admin documentation. For the Artemis request, callback, WebSocket, ingestion, search, and memory boundaries, see the AI Pipelines catalog; service-owned execution and retrieval details are documented in the Iris pipeline system and Iris RAG pipeline.

Global search (Weaviate)​

Artemis's keyword and semantic search feature (global search) uses Weaviate independently of Iris. For full setup instructions — deploying Weaviate, choosing an embedding strategy, configuring Artemis, and operating the instance — see the Global Search & Weaviate Setup admin page.

Athena Service​

Athena is an EduTelligence assessment service that Artemis uses for configured feedback-suggestion modules and related assessment workflows. To enable Athena, special configuration is required. The AI Pipelines catalog describes the Artemis-side selection, forwarding, scheduling, and repository-export boundaries; the Athena module structure documents the service-owned module contract.

Enable Athena​

Set the Athena module-feature flag in your deployment-specific override (e.g. application-prod.yml, or the equivalent file mounted into your container — not the source-tree src/main/resources/config/application-artemis.yml, which would be ignored by a packaged or containerized deployment):

artemis:
    athena:
        enabled: true

Configure the Athena boundary​

Configure the Athena endpoint and shared secret in the active deployment-specific configuration. Artemis discovers available modules from Athena; exercise configuration selects an allowed module rather than using a static per-type module mapping.

artemis:
    athena:
        url: https://<athena-service>
        secret: <shared-secret>
        # Optional: restrict modules unless a course grants restricted-module access.
        restricted-modules: <comma-separated-module-names>

Use a deployment-managed shared secret. For the service-side module layout and decorator contracts, refer to the Athena module structure.

Other Extension Services​

Text Assessment Analytics Service​

Text Assessment Analytics is an internal analytics service used to gather data regarding the features of the text assessment process. Certain assessment events are tracked:

  1. Adding new feedback on a manually selected block
  2. Adding new feedback on an automatically selected block
  3. Deleting a feedback
  4. Clicking to resolve feedback conflicts
  5. Clicking to view origin submission of automatically generated feedback
  6. Hovering over the text assessment feedback impact warning
  7. Editing/Discarding an automatically generated feedback
  8. Clicking the Submit button when assessing a text submission
  9. Clicking the Assess Next button when assessing a text submission

These events are tracked by attaching a POST call to the respective DOM elements on the client side. The POST call accesses the TextAssessmentEventResource which then adds the events in its respective table. This feature is disabled by default. We can enable it by modifying the configuration in the file: src/main/resources/config/application-artemis.yml like so:

info:
    textAssessmentAnalyticsEnabled: true

Apollon Service​

Apollon Converter is needed to convert models from their JSON representation to PDF. Special configuration is required:

Enable Apollon​

Set the Apollon module-feature flag in your deployment-specific override (e.g. application-prod.yml, or the equivalent file mounted into your container — not the source-tree src/main/resources/config/application-artemis.yml, which would be ignored by a packaged or containerized deployment):

artemis:
    apollon:
        enabled: true

Configure API Endpoints​

The Apollon conversion service is running on a dedicated machine and is addressed via HTTP. Add its endpoint to the same active deployment-specific override used above:

artemis:
    apollon:
        conversion-service-url: http://localhost:8080

Hermes Service​

Push notifications for the mobile Android and iOS clients rely on the Hermes service. To enable push notifications the Hermes service needs to be started separately and the configuration of the Artemis instance must be extended.

Configure and start Hermes​

To run Hermes, you need to clone the repository and replace the placeholders within the docker-compose file.

The following environment variables need to be updated for push notifications to Apple devices:

  • APNS_CERTIFICATE_PATH: String - Path to the APNs certificate .p12 file as described here
  • APNS_CERTIFICATE_PWD: String - The APNS certificate password
  • APNS_PROD_ENVIRONMENT: Bool - True if it should use the Production APNS Server (Default false)

Furthermore, the <APNS_Key>.p12 needs to be mounted into the Docker under the above specified path.

To run the services for Android support the following environment variable is required:

  • GOOGLE_APPLICATION_CREDENTIALS: String - Path to the firebase.json

Furthermore, the Firebase.json needs to be mounted into the Docker under the above specified path.

To run both APNS and Firebase, configure the environment variables for both.

To start Hermes, run the docker compose up command in the folder where the docker-compose file is located.

Artemis Configuration​

The Hermes service is running on a dedicated machine and is addressed via HTTPS. We need to extend the Artemis configuration in the file src/main/resources/config/application-artemis.yml like:

artemis:
    # ...
    push-notification-relay: <url>

Hyperion Service​

Aeolus Service​

Aeolus is a service that provides a REST API for the Artemis platform to generate custom build plans for programming exercises. It is designed to be used in combination with the Artemis platform to provide build plans in multiple CI systems, currently Jenkins and LocalCI.

This section outlines how to set up Aeolus in your own Artemis instance.

Prerequisites​

  • Ensure you have a running instance of Artemis.
  • Set up a running instance of Aeolus. See the Aeolus documentation for more information.

Enable the aeolus Spring profile​

--spring.profiles.active=dev,localci,localvc,artemis,scheduling,buildagent,core,local,aeolus

Configure the Aeolus Endpoint​

The Aeolus service can run on a dedicated machine since Artemis accesses it via a REST API call. We need to extend the configuration in the file src/main/resources/config/application-artemis.yml to include the Aeolus endpoint. How to do this is described in the configuration documentation for Aeolus.

Setup Guide for Exchange with the Sharing Platform​

Background​

Sharing Platform is an open platform for sharing teaching materials related to programming. It is operated by the University of Innsbruck. While primarily designed as an open exchange platform, it also provides features such as private group exchanges and the ability to restrict public access to certain content, such as the solution repository of an Artemis exercise.

For more details, visit help menu of the sharing platform.

To facilitate the exchange of programming exercises among instructors, the sharing platform offers a connector to Artemis, enabling any Artemis instance to integrate with the platform for seamless sharing.

The Sharing Platform is open source. The source code can be found at https://sharing-codeability.uibk.ac.at/development/sharing/codeability-sharing-platform.

Prerequisites​

To connect to the sharing platform, you need an API key. To request one, contact the platform maintainers at artemis-support-informatik@uibk.ac.at and provide the URL of your active Artemis instance.

Important: Sharing only works if your Artemis instance is accessible on the internet. If making your instance publicly available is not an option, the maintainers can provide a list of required Artemis URLs that must be accessible to the sharing platform.

Configuration​

Once you receive your API key, you should add it to the configuration file application-core.yml or your .env file:

Option 1: application-artemis.yml

artemis:
    sharing:
        enabled: true
        # Shared common secret
        apikey: <your API Key>
        serverurl: https://search.sharing-codeability.uibk.ac.at/
        actionname: Export to Artemis@myUniversity

Option 2: .env file for Docker initialization

ARTEMIS_SHARING_ENABLED=true
ARTEMIS_SHARING_SERVERURL=https://search.sharing-codeability.uibk.ac.at/
ARTEMIS_SHARING_APIKEY=<Enter your API Key here>
ARTEMIS_SHARING_ACTIONNAME=Export to Artemis@<Enter an ID here>

Once configured, restart your Artemis instance.

Instructor Access Requirements​

For instructors to exchange programming exercises, they need an account on the sharing platform. They can register using one of the following methods:

  • EduID Authentication: The simplest way is through EduID (Austria) or EduID (Germany). Forward the necessary connection details to the sharing platform maintainers.
  • GitLab-Based Registration: If EduID is not an option, users can register via the sharing platform's GitLab instance. However, for security reasons, self-registration is restricted to certain email domains. To enable access, forward the desired domains to the maintainers for approval.

Troubleshooting​

To assist in troubleshooting, the sharing profile includes an additional health indicator, accessible via the Administration -> Health menu.

Sharing health indicator 1

Under Details, you will typically find the following entries:

Sharing health indicator 2
  • The first entry is an initialization request sent after startup.
  • The second entry reflects the subsequent receipt of the connector configuration from the sharing platform.
  • Additional entries represent regular configuration polling requests from the sharing platform.

The Details log stores the last 10 entries.

If the health status is not up, check the error message in the details. If the issue is unclear, feel free to contact the sharing platform maintainers for support.

Conclusion​

Once everything is set up correctly, you should see the Sharing button Artemis button in the Programming Exercise Details dialog in Artemis.

Similarly, the Sharing button Sharing button should appear on the sharing platform for any programming exercise available there.

Before testing the import and export functionality, refer to the user documentation for further details.

Search documentation