{"id":26103676,"url":"https://github.com/aleph-alpha/intelligence-layer-sdk","last_synced_at":"2025-04-12T18:08:39.114Z","repository":{"id":237271164,"uuid":"710215521","full_name":"Aleph-Alpha/intelligence-layer-sdk","owner":"Aleph-Alpha","description":"a unified framework for leveraging LLMs","archived":false,"fork":false,"pushed_at":"2025-04-11T06:24:48.000Z","size":10643,"stargazers_count":70,"open_issues_count":3,"forks_count":8,"subscribers_count":8,"default_branch":"main","last_synced_at":"2025-04-12T18:07:50.184Z","etag":null,"topics":["artificial-intelligence","large-language-models"],"latest_commit_sha":null,"homepage":"https://aleph-alpha-intelligence-layer.readthedocs-hosted.com","language":"Python","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Aleph-Alpha.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE.md","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2023-10-26T08:52:19.000Z","updated_at":"2025-04-11T06:22:33.000Z","dependencies_parsed_at":"2024-05-13T08:29:31.826Z","dependency_job_id":"0c51028e-ce33-4204-a5c8-b8d14f44ffab","html_url":"https://github.com/Aleph-Alpha/intelligence-layer-sdk","commit_stats":null,"previous_names":["aleph-alpha/intelligence-layer-sdk"],"tags_count":33,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Aleph-Alpha%2Fintelligence-layer-sdk","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Aleph-Alpha%2Fintelligence-layer-sdk/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Aleph-Alpha%2Fintelligence-layer-sdk/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Aleph-Alpha%2Fintelligence-layer-sdk/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Aleph-Alpha","download_url":"https://codeload.github.com/Aleph-Alpha/intelligence-layer-sdk/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":248610340,"owners_count":21132921,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["artificial-intelligence","large-language-models"],"created_at":"2025-03-09T20:42:01.412Z","updated_at":"2025-04-12T18:08:39.084Z","avatar_url":"https://github.com/Aleph-Alpha.png","language":"Python","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Aleph Alpha Intelligence Layer\n\nThe Aleph Alpha Intelligence Layer️ offers a comprehensive suite of development tools for crafting solutions that harness the capabilities of large language models (LLMs).\nWith a unified framework for LLM-based workflows, it facilitates seamless AI product development, from prototyping and prompt experimentation to result evaluation and deployment.\n\nThe key features of the Intelligence Layer are:\n\n- **Composability:** Streamline your journey from prototyping to scalable deployment. The Intelligence Layer SDK offers seamless integration with diverse evaluation methods, manages concurrency, and orchestrates smaller tasks into complex workflows.\n- **Evaluability:** Continuously evaluate your AI applications against your quantitative quality requirements. With the Intelligence Layer SDK you can quickly iterate on different solution strategies, ensuring confidence in the performance of your final product. Take inspiration from the provided evaluations for summary and search when building a custom evaluation logic for your own use case.\n- **Traceability:** At the core of the Intelligence Layer is the belief that all AI processes must be auditable and traceable. We provide full observability by seamlessly logging each step of every workflow. This enhances your debugging capabilities and offers greater control post-deployment when examining model responses.\n- **Examples:** Get started by following our hands-on examples, demonstrating how to use the Intelligence Layer SDK and interact with its API.\n\n\n\n# Table of contents\n- [Aleph Alpha Intelligence Layer](#aleph-alpha-intelligence-layer)\n- [Table of contents](#table-of-contents)\n- [Installation](#installation)\n  - [Local installation (for development and tutorials)](#local-installation-for-development-and-tutorials)\n  - [Add the Intelligence Layer to your project dependencies](#add-the-intelligence-layer-to-your-project-dependencies)\n  - [How to use the Intelligence Layer in Docker](#how-to-use-the-intelligence-layer-in-docker)\n    - [Via the GitHub repository](#via-the-github-repository)\n- [Getting started](#getting-started)\n    - [Setup LLM access](#setup-llm-access)\n  - [Tutorial Notebooks](#tutorial-notebooks)\n  - [How-Tos](#how-tos)\n- [Models](#models)\n- [Example index](#example-index)\n- [References](#references)\n- [License](#license)\n- [For Developers](#for-developers)\n  - [How to contribute](#how-to-contribute)\n  - [Executing tests](#executing-tests)\n\n# Installation\n\n## Local installation (for development and tutorials)\n\nClone the Intelligence Layer repository from GitHub.\n\n```bash\ngit clone git@github.com:Aleph-Alpha/intelligence-layer-sdk.git\n```\n\nThe Intelligence Layer uses `poetry`, which serves as the package manager and manages the virtual environments.\nWe recommend installing poetry globally, while still isolating it in a virtual environment, using pipx, following the [official instructions](https://python-poetry.org/docs/#installation).\nAfterward, simply run `poetry install` to create a new virtual environment and install all project dependencies.\n\n```bash\npoetry install\n```\nThe environment can be activated via `poetry shell`. See the official poetry documentation for more information.\n\n## Add the Intelligence Layer to your project dependencies\n\nTo install the Aleph-Alpha Intelligence Layer from the JFrog artifactory in you project, you have to add this information to your poetry setup via the following four steps. First, add the artifactory as a source to your project via\n```bash\npoetry source add --priority=explicit artifactory https://alephalpha.jfrog.io/artifactory/api/pypi/python/simple\n```\nSecond, to install the poetry environment, export your JFrog credentials to the environment\n```bash\nexport POETRY_HTTP_BASIC_ARTIFACTORY_USERNAME=your@username.here\nexport POETRY_HTTP_BASIC_ARTIFACTORY_PASSWORD=your-token-here\n```\nThird, add the Intelligence Layer to the project\n```bash\npoetry add --source artifactory intelligence-layer\n```\nFourth, execute\n```bash\npoetry install\n```\n\nNow the Intelligence Layer should be available as a Python package and ready to use.\n\n```py\nfrom intelligence_layer.core import Task\n```\n\nIn VSCode, to enable auto-import up to the second depth, where all symbols are exported, add the following entry to your `./.vscode/settings.json`:\n\n``` json\n\"python.analysis.packageIndexDepths\": [\n    {\n        \"name\": \"intelligence_layer\",\n        \"depth\": 2\n    }\n]\n```\n\n## How to use the Intelligence Layer in Docker\n\n### Via the GitHub repository\n\nTo use the Intelligence Layer in Docker, a few settings are needed to not leak your GitHub token.\n\nYou will need your GitHub token set in your environment.\n\nIn order to modify the `git config` add the following to your docker container:\n\n```dockerfile\nRUN apt-get -y update\nRUN apt-get -y install git curl gcc python3-dev\nRUN pip install poetry\n\nRUN poetry install --no-dev --no-interaction --no-ansi \\\n    \u0026\u0026  rm -f ~/.gitconfig\n```\n\n# Getting started\n\n\u003e 📘 Not sure where to start? Familiarize yourself with the Intelligence Layer using the **below notebooks as interactive tutorials**.\n\u003e If you prefer you can also **read about the [concepts](Concepts.md)** first.\n\nThe tutorials aim to guide you through implementing several common use-cases with the Intelligence Layer. They introduce you to key concepts and enable you to create your own use-cases. In general the tutorials are build in a way that you can simply hop into the topic you are most interested in. However, for starters we recommend to read through the `Summarization` tutorial first. It explains the core concepts of the intelligence layer in more depth while for the other tutorials we assume that these concepts are known.\n\n### Setup LLM access\n\nThe tutorials require access to an LLM endpoint. You can choose between using the Aleph Alpha API (`https://api.aleph-alpha.com`) or an on-premise setup by configuring the appropriate environment variables. To configure the environment variables, create a `.env` file in the root directory of the project and copy the contents of the `.env.example` file into it.\n\nTo use the **Aleph Alpha API**, that is set as the default host URL, set the `AA_TOKEN` variable to your [Aleph Alpha access token,](https://docs.aleph-alpha.com/docs/account/#create-a-new-token) and you are good to go.\n\nTo use an **on-premises setup**, set the `CLIENT_URL` variable to your host URL.\n\n## Tutorial Notebooks\n\n| Order | Topic                  | Description                                           | Notebook 📓                                                                                                            |\n|-------|------------------------|-------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------|\n| 1     | Summarization          | Summarize a document                                  | [summarization.ipynb](./src/documentation/summarization.ipynb)                                                         |\n| 2     | Question Answering     | Various approaches for QA                             | [qa.ipynb](./src/documentation/qa.ipynb)                                                                               |\n| 3     | Classification         | Learn about two methods of classification             | [classification.ipynb](./src/documentation/classification.ipynb)                                                       |\n| 4     | Evaluation             | Evaluate LLM-based methodologies                      | [evaluation.ipynb](./src/documentation/evaluation.ipynb)                                                               |\n| 5     | Parameter Optimization | Compare Task configuration for optimization           | [parameter_optimization.ipynb](./src/documentation/parameter_optimization.ipynb)                                       |\n| 6     | Attention Manipulation | Use `TextControls` for Attention Manipulation (AtMan) | [attention_manipulation_with_text_controls.ipynb](./src/documentation/attention_manipulation_with_text_controls.ipynb) |\n| 7     | Elo QA Evaluation      | Evaluate QA tasks in an Elo ranking                   | [elo_qa_eval.ipynb](./src/documentation/elo_qa_eval.ipynb)                                                             |\n| 8     | Quickstart Task        | Build a custom `Task` for your use case               | [quickstart_task.ipynb](./src/documentation/quickstart_task.ipynb)                                                     |\n| 9     | Document Index         | Connect your proprietary knowledge base               | [document_index.ipynb](./src/documentation/document_index.ipynb)                                                       |\n| 10    | Human Evaluation       | Connect to Argilla for manual evaluation              | [human_evaluation.ipynb](./src/documentation/human_evaluation.ipynb)                                                   |\n| 11    | Performance tips       | Contains some small tips for performance              | [performance_tips.ipynb](./src/documentation/performance_tips.ipynb)                                                   |\n| 12    | Deployment             | Shows how to deploy a Task in a minimal FastAPI app.  | [fastapi_tutorial.ipynb](./src/documentation/fastapi_tutorial.ipynb)                                                   |\n| 13    | Issue Classification   | Deploy a Task in Kubernetes to classify Jira issues   | [Found in adjacent repository](https://github.com/Aleph-Alpha/IL-Classification-Journey)                               |\n| 14    | Evaluate with Studio                 | Shows how to evaluate your `Task` using Studio           | [evaluate_with_studio.ipynb](./src/documentation/evaluate_with_studio.ipynb)                                                                       |\n\n## How-Tos\n\nThe how-tos are quick lookups about how to do things. Compared to the tutorials, they are shorter and do not explain the concepts they are using in-depth.\n\n| Tutorial                                                                                                                                               | Description                                                                |\n|--------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------|\n| **Tasks**                                                                                                                                              |                                                                            |\n| [...define a task](./src/documentation/how_tos/how_to_define_a_task.ipynb)                                                                             | How to come up with a new task and formulate it                            |\n| [...implement a task](./src/documentation/how_tos/how_to_implement_a_task.ipynb)                                                                       | Implement a formulated task and make it run with the Intelligence Layer    |\n| [...debug and log a task](./src/documentation/how_tos/how_to_log_and_debug_a_task.ipynb)                                                               | Tools for logging and debugging in tasks                                   |\n| **Analysis Pipeline**                                                                                                                                  |                                                                            |\n| [...implement a simple evaluation and aggregation logic](./src/documentation/how_tos/how_to_implement_a_simple_evaluation_and_aggregation_logic.ipynb) | Basic examples of evaluation and aggregation logic                         |\n| [...create a dataset](./src/documentation/how_tos/how_to_create_a_dataset.ipynb)                                                                       | Create a dataset used for running a task                                   |\n| [...run a task on a dataset](./src/documentation/how_tos/how_to_run_a_task_on_a_dataset.ipynb)                                                         | Run a task on a whole dataset instead of single examples                   |\n| [...resume a run after a crash](./src/documentation/how_tos/how_to_resume_a_run_after_a_crash.ipynb)                                                   | Resume a run after a crash or exception occurred                           |\n| [...evaluate multiple runs](./src/documentation/how_tos/how_to_evaluate_runs.ipynb)                                                                    | Evaluate (multiple) runs in a single evaluation                            |\n| [...aggregate multiple evaluations](./src/documentation/how_tos/how_to_aggregate_evaluations.ipynb)                                                    | Aggregate (multiple) evaluations in a single aggregation                   |\n| [...retrieve data for analysis](./src/documentation/how_tos/how_to_retrieve_data_for_analysis.ipynb)                                                   | Retrieve experiment data in multiple different ways                        |\n| [...implement a custom human evaluation](./src/documentation/how_tos/how_to_human_evaluation_via_argilla.ipynb)                                        | Necessary steps to create an evaluation with humans as a judge via Argilla |\n| [...implement elo evaluations](./src/documentation/how_tos/how_to_implement_elo_evaluations.ipynb)                                                     | Evaluate runs and create ELO ranking for them                              |\n| [...implement incremental evaluation](./src/documentation/how_tos/how_to_implement_incremental_evaluation.ipynb)                                       | Implement and run an incremental evaluation                                |\n| **Studio**                                                                                                                                             |                                                                            |\n| [...use Studio with traces](./src/documentation/how_tos/studio/how_to_use_studio_with_traces.ipynb)                                                    | Submitting Traces to Studio for debugging                                  |\n| [...upload existing datasets](./src/documentation/how_tos/studio/how_to_upload_existing_datasets_to_studio.ipynb)                                      | Upload Datasets to Studio                                                  |\n| [...execute a benchmark](./src/documentation/how_tos/studio/how_to_execute_a_benchmark.ipynb)                                                          | Execute a benchmark                                                        |\n\n\n\n# Models\n\nCurrently, we support a bunch of models accessible via the Aleph Alpha API. Depending on your local setup, you may even have additional models available.\n\n| Model                                                                                                                                                                     | Description                                                                                                                                                                                                                                        |\n|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| [LuminousControlModel](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.core.html#intelligence_layer.core.LuminousControlModel) | Any control-type model based on the first Luminous generation, specifically `luminous-base-control`, `luminous-extended-control` and `luminous-supreme-control`.                                                                                   |\n| [Pharia1ChatModel](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.core.html#intelligence_layer.core.Pharia1ChatModel)         | Pharia-1 based models prompted for multi-turn interactions. Includes `pharia-1-llm-7b-control` and `pharia-1-llm-7b-control-aligned`.                                                                                                              |\n| [Llama3InstructModel](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.core.html#intelligence_layer.core.Llama3InstructModel)   | Llama-3 based models prompted for one-turn instruction answering. Includes `llama-3-8b-instruct`, `llama-3-70b-instruct`, `llama-3.1-8b-instruct` and `llama-3.1-70b-instruct`.                                                                    |\n| [Llama3ChatModel](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.core.html#intelligence_layer.core.Llama3ChatModel)           | Llama-3 based models prompted for multi-turn interactions. Includes `llama-3-8b-instruct`, `llama-3-70b-instruct`, `llama-3.1-8b-instruct` and `llama-3.1-70b-instruct`.                                                                           |\n\n# Example index\n\nTo give you a starting point for using the Intelligence Layer, we provide some pre-configured `Task`s that are ready to use out-of-the-box, as well as an accompanying \"Getting started\" guide in the form of Jupyter Notebooks.\n\n| Type      | Task                                                                                                                                                                                                            | Description                                                                                                                                                                                                                                |\n|-----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| Classify  | [EmbeddingBasedClassify](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.examples.html#intelligence_layer.examples.EmbeddingBasedClassify)                         | Classify a short text by computing its similarity with example texts for each class.                                                                                                                                                       |\n| Classify  | [PromptBasedClassify](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.examples.html#intelligence_layer.examples.PromptBasedClassify)                               | Classify a short text by assessing each class' probability using zero-shot prompting.                                                                                                                                                      |\n| Classify  | [PromptBasedClassifyWithDefinitions](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.examples.html#intelligence_layer.examples.PromptBasedClassifyWithDefinitions) | Classify a short text by assessing each class' probability using zero-shot prompting. Each class is defined by a natural language description.                                                                                             |\n| Classify  | [KeywordExtract](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.examples.html#intelligence_layer.examples.KeywordExtract)                                         | Generate matching labels for a short text.                                                                                                                                                                                                 |\n| QA        | [MultipleChunkRetrieverQa](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.examples.html#intelligence_layer.examples.MultipleChunkRetrieverQa)                     | Answer a question based on an entire knowledge base. Recommended for most RAG-QA use-cases.                                                                                                                                                |\n| QA        | [LongContextQa](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.examples.html#intelligence_layer.examples.LongContextQa)                                           | Answer a question based on one document of any length.                                                                                                                                                                                     |\n| QA        | [MultipleChunkQa](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.examples.html#intelligence_layer.examples.MultipleChunkQa)                                       | Answer a question based on a list of short texts.                                                                                                                                                                                          |\n| QA        | [SingleChunkQa](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.examples.html#intelligence_layer.examples.SingleChunkQa)                                           | Answer a question based on a short text.                                                                                                                                                                                                   |\n| QA        | [RetrieverBasedQa (deprecated)](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.examples.html#intelligence_layer.examples.RetrieverBasedQa)                        | Answer a question based on a document base using a [BaseRetriever](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.connectors.html#intelligence_layer.connectors.BaseRetriever) implementation. |\n| Search    | [Search](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.examples.html#intelligence_layer.examples.Search)                                                         | Search for texts in a document base using a [BaseRetriever](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.connectors.html#intelligence_layer.connectors.BaseRetriever) implementation.        |\n| Search    | [ExpandChunks](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.examples.html#intelligence_layer.examples.ExpandChunks)                                             | Expand chunks retrieved with a [BaseRetriever](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.connectors.html#intelligence_layer.connectors.BaseRetriever) implementation.                     |\n| Summarize | [SteerableLongContextSummarize](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.examples.html#intelligence_layer.examples.SteerableLongContextSummarize)           | Condense a long text into a summary with a natural language instruction.                                                                                                                                                                   |\n| Summarize | [SteerableSingleChunkSummarize](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.examples.html#intelligence_layer.examples.SteerableSingleChunkSummarize)           | Condense a short text into a summary with a natural language instruction.                                                                                                                                                                  |\n| Summarize | [RecursiveSummarize](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/intelligence_layer.examples.html#intelligence_layer.examples.RecursiveSummarize)                                 | Recursively condense a text into a summary.                                                                                                                                                                                                |\n\nNote that we do not expect the above use cases to solve all of your issues.\nInstead, we encourage you to think of our pre-configured use cases as a foundation to fast-track your development process.\nBy leveraging these tasks, you gain insights into the framework's capabilities and best practices.\n\nWe encourage you to copy and paste these use cases directly into your own project.\nFrom here, you can customize everything, including the prompt, model, and more intricate functional logic.\nFor more information, check the [tutorials](#tutorial-notebooks) and the [how-tos](#how-tos)\n\n# References\n\nThe full code documentation can be found in our read-the-docs [here](https://aleph-alpha-intelligence-layer.readthedocs-hosted.com/en/latest/)\n\n# License\n\nThis project can only be used after signing the agreement with Aleph Alpha®. Please refer to the [LICENSE](LICENSE.md) file for more details.\n\n# For Developers\n\nFor further information check out our different guides and documentations:\n- [Concepts.md](https://github.com/Aleph-Alpha/intelligence-layer-sdk/blob/main/Concepts.md) for an overview of what Intelligence Layer is and how it works.\n- [style_guide.md](https://github.com/Aleph-Alpha/intelligence-layer-sdk/blob/main/style_guide.md) on how we write and document code.\n- [RELEASE.md](https://github.com/Aleph-Alpha/intelligence-layer-sdk/blob/main/RELEASE.md) for the release process of IL.\n- [CHANGELOG.md](https://github.com/Aleph-Alpha/intelligence-layer-sdk/blob/main/CHANGELOG.md) for the latest changes.\n\n## How to contribute\n:warning: **Warning:** This repository is open-source. Any contributions and MR discussions will be publicly accessible.\n\n\n1. Share the details of your problem with us.\n2. Write your code according to our [style guide](https://github.com/Aleph-Alpha/intelligence-layer-sdk/blob/main/style_guide.md).\n3. Add doc strings to your code as described [here](https://github.com/Aleph-Alpha/intelligence-layer-sdk/blob/main/style_guide.md#docstrings).\n4. Write tests for new features ([Executing Tests](#executing-tests)).\n5. Add an how_to and/or notebook as a documentation (check out [this](https://github.com/Aleph-Alpha/intelligence-layer-sdk/blob/main/style_guide.md#documentation) for guidance).\n6. Update the [Changelog](https://github.com/Aleph-Alpha/intelligence-layer-sdk/blob/main/CHANGELOG.md) with your changes.\n7. Request a review for the MR, so that it can be merged.\n\n\n\n## Executing tests\nIf you want to execute all tests, you first need to spin up your docker container and execute the commands with your own `GITLAB_TOKEN`.\n\n```bash\n  export GITLAB_TOKEN=...\n  echo $GITLAB_TOKEN | docker login registry.gitlab.aleph-alpha.de -u your_email@for_gitlab --password-stdin\n  docker compose pull to update containers\n```\n\n Afterwards simply run `docker compose up --build`. You can then either run the tests in your IDE or via the terminal.\n\n**In VSCode**\n1. Sidebar \u003e Testing\n2. Select pytest as framework for the tests\n3. Select `intelligence_layer/tests` as source of the tests\n\nYou can then run the tests from the sidebar.\n\n**In a terminal**\nIn order to run a local proxy of the CI pipeline (required to merge) you can run\n\u003e scripts/all.sh\n\nThis will run linters and all tests.\nThe scripts to run single steps can also be found in the `scripts` folder.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Faleph-alpha%2Fintelligence-layer-sdk","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Faleph-alpha%2Fintelligence-layer-sdk","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Faleph-alpha%2Fintelligence-layer-sdk/lists"}