diff --git a/.github/workflows/docker-publish-image-stable.yml b/.github/workflows/docker-publish-image-stable.yml
new file mode 100644
index 00000000..5c550c6a
--- /dev/null
+++ b/.github/workflows/docker-publish-image-stable.yml
@@ -0,0 +1,40 @@
+name: Build and publish docker image
+on:
+  push:
+    tags: '*.*.*'
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}_stable
+
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@f054a8b539a109f9f41c372932f1ae047eff08c9
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@98669ae865ea3cffbcbaa878cf57c20bbf1c6c38
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@ad44023a93711e3deb337508980b4b5e9bcdc5dc
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
diff --git a/.github/workflows/docker-publish-image-unstable.yml b/.github/workflows/docker-publish-image-unstable.yml
new file mode 100644
index 00000000..534771ce
--- /dev/null
+++ b/.github/workflows/docker-publish-image-unstable.yml
@@ -0,0 +1,44 @@
+name: Build and publish docker image
+on:
+  push:
+    branches: [ develop ]
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}_unstable
+
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@f054a8b539a109f9f41c372932f1ae047eff08c9
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@98669ae865ea3cffbcbaa878cf57c20bbf1c6c38
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+          
+      - name: Get current date
+        id: date
+        run: echo "::set-output name=date::$(date +'%Y.%m.%d')"
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@ad44023a93711e3deb337508980b4b5e9bcdc5dc
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}_${{ steps.date.outputs.date }}
+          labels: ${{ steps.meta.outputs.labels }}
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 00000000..7c4c71da
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,41 @@
+name: Build and push docs
+on: 
+  push:
+    branches: [ master, develop ]
+
+jobs:
+  build-and-deploy:
+    concurrency: ci-${{ github.ref }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+        
+      - name: Set up Python 3.10
+        uses: actions/setup-python@v2
+        with:
+          python-version: "3.10"
+
+      - name: Install pipenv
+        run: |
+          pip install pipenv
+
+      - name: Install dependencies
+        run: |
+          pipenv install --dev
+          
+      - name: Create config for server
+        run: |
+          mv example_config.ini config.ini
+          
+      - name: Build docs
+        run: |
+          cd docs
+          pipenv run make html
+
+      - name: Deploy
+        uses: JamesIves/github-pages-deploy-action@v4.2.3
+        with:
+          branch: docs
+          folder: ./docs/build/html/
+          target-folder: ${{ github.ref_name }}
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 00000000..1a4601cb
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,36 @@
+name: Test and Push coverage to Coveralls
+
+on: [push, pull_request]
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v2
+      with:
+        python-version: "3.10"
+        
+    - name: Install pipenv
+      run: |
+        pip install pipenv
+      
+    - name: Install dependencies
+      run: |
+        pipenv install --dev
+        
+    - name: Create config for server
+      run: |
+        mv example_config.ini config.ini
+                
+    - name: Run tests
+      run: |
+        pipenv run coverage run -m unittest discover tests
+
+    - name: Push report to coveralls.io
+      env: 
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      run: |
+        pipenv run coveralls --service=github
diff --git a/.gitignore b/.gitignore
index d3d7ee82..1cfa01fd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -139,5 +139,5 @@ dmypy.json
 ## Morelia stuff
 db_sqlite.db
 config.ini
-t.py
 ngrok.exe
+/docs/log/
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 00000000..8dab21ca
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,24 @@
+# syntax=docker/dockerfile:1
+
+FROM python:3.10.2-slim-bullseye
+
+WORKDIR /morelia-server
+
+COPY Pipfile Pipfile
+COPY Pipfile.lock Pipfile.lock
+
+RUN pip3 install pipenv
+RUN pipenv install --ignore-pipfile
+
+COPY example_config.ini config.ini
+
+COPY . .
+
+CMD [ "pipenv", "run", \
+    "python", "-m", \
+    "uvicorn", "server:app", \
+    "--host", "0.0.0.0", \
+    "--port", "8000", \
+    "--reload", "--use-colors", \
+    "--http", "h11", "--ws", "websockets" \
+    ]
diff --git a/Pipfile b/Pipfile
index 3971212c..737604a4 100644
--- a/Pipfile
+++ b/Pipfile
@@ -8,6 +8,7 @@ flake8 = "*"
 pyflakes = "*"
 pycodestyle = "*"
 mccabe = "*"
+coveralls = "==3.3.1"
 
 [packages]
 fastapi = "==0.71.0"
@@ -16,7 +17,7 @@ jinja2 = "==3.0.3"
 aiofiles = "==0.7.0"
 email-validator = "==1.1.3"
 sqlobject = "==3.9.1"
-loguru = "==0.5.3"
+loguru = "==0.6.0"
 websockets = "==10.1"
 pydantic = "==1.9.0"
 fastapi-login = "==1.7.3"
@@ -25,6 +26,8 @@ websocket-client = "==1.2.3"
 coverage = "==6.2"
 requests = "==2.27.1"
 win32-setctime = "*"
+sphinx = "==4.4.0"
+furo = "==2022.1.2"
 
 [requires]
 python_version = "3.10"
diff --git a/Pipfile.lock b/Pipfile.lock
index e5db376c..f29da7e1 100644
--- a/Pipfile.lock
+++ b/Pipfile.lock
@@ -1,7 +1,7 @@
 {
     "_meta": {
         "hash": {
-            "sha256": "6758f84d8690f63bbde83833ba2941743bf5e26f28a8a1cf52bc7517555d5b2f"
+            "sha256": "0628c267ce6c693fba4c09dc6e7555a5bf26b504ebfd00b0684590418b9cdd9e"
         },
         "pipfile-spec": 6,
         "requires": {
@@ -24,6 +24,13 @@
             "index": "pypi",
             "version": "==0.7.0"
         },
+        "alabaster": {
+            "hashes": [
+                "sha256:446438bdcca0e05bd45ea2de1668c1d9b032e1a9154c2c259092d77031ddd359",
+                "sha256:a661d72d58e6ea8a57f7a86e37d86716863ee5e92788398526d58b26a4e4dc02"
+            ],
+            "version": "==0.7.12"
+        },
         "anyio": {
             "hashes": [
                 "sha256:a0aeffe2fb1fdf374a8e4b471444f0f3ac4fb9f5a5b542b48824475e0042a5a6",
@@ -34,11 +41,27 @@
         },
         "asgiref": {
             "hashes": [
-                "sha256:4ef1ab46b484e3c706329cedeff284a5d40824200638503f5768edb6de7d58e9",
-                "sha256:ffc141aa908e6f175673e7b1b3b7af4fdb0ecb738fc5c8b88f69f055c2415214"
+                "sha256:2f8abc20f7248433085eda803936d98992f1343ddb022065779f37c5da0181d0",
+                "sha256:88d59c13d634dcffe0510be048210188edd79aeccb6a6c9028cdad6f31d730a9"
             ],
-            "markers": "python_version >= '3.6'",
-            "version": "==3.4.1"
+            "markers": "python_version >= '3.7'",
+            "version": "==3.5.0"
+        },
+        "babel": {
+            "hashes": [
+                "sha256:ab49e12b91d937cd11f0b67cb259a57ab4ad2b59ac7a3b41d6c06c0ac5b0def9",
+                "sha256:bc0c176f9f6a994582230df350aa6e05ba2ebe4b3ac317eab29d9be5d2768da0"
+            ],
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
+            "version": "==2.9.1"
+        },
+        "beautifulsoup4": {
+            "hashes": [
+                "sha256:9a315ce70049920ea4572a4055bc4bd700c940521d36fc858205ad4fcde149bf",
+                "sha256:c23ad23c521d818955a4151a67d81580319d4bf548d3d49f4223ae041ff98891"
+            ],
+            "markers": "python_version >= '3.1'",
+            "version": "==4.10.0"
         },
         "certifi": {
             "hashes": [
@@ -49,11 +72,11 @@
         },
         "charset-normalizer": {
             "hashes": [
-                "sha256:876d180e9d7432c5d1dfd4c5d26b72f099d503e8fcc0feb7532c9289be60fcbd",
-                "sha256:cb957888737fc0bbcd78e3df769addb41fd1ff8cf950dc9e7ad7793f1bf44455"
+                "sha256:2842d8f5e82a1f6aa437380934d5e1cd4fcf2003b06fed6940769c164a480a45",
+                "sha256:98398a9d69ee80548c762ba991a4728bfc3836768ed226b3945908d1a688371c"
             ],
             "markers": "python_version >= '3'",
-            "version": "==2.0.10"
+            "version": "==2.0.11"
         },
         "click": {
             "hashes": [
@@ -118,11 +141,19 @@
         },
         "dnspython": {
             "hashes": [
-                "sha256:95d12f6ef0317118d2a1a6fc49aac65ffec7eb8087474158f42f26a639135216",
-                "sha256:e4a87f0b573201a0f3727fa18a516b055fd1107e0e5477cded4a2de497df1dd4"
+                "sha256:081649da27ced5e75709a1ee542136eaba9842a0fe4c03da4fb0a3d3ed1f3c44",
+                "sha256:e79351e032d0b606b98d38a4b0e6e2275b31a5b85c873e587cc11b73aca026d6"
             ],
-            "markers": "python_version >= '3.6'",
-            "version": "==2.1.0"
+            "markers": "python_version >= '3.6' and python_version < '4.0'",
+            "version": "==2.2.0"
+        },
+        "docutils": {
+            "hashes": [
+                "sha256:686577d2e4c32380bb50cbb22f575ed742d58168cee37e99117a854bcd88f125",
+                "sha256:cf316c8370a737a022b72b56874f6602acf974a37a9fba42ec2876387549fc61"
+            ],
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4'",
+            "version": "==0.17.1"
         },
         "email-validator": {
             "hashes": [
@@ -156,13 +187,21 @@
             "markers": "python_version >= '3.4'",
             "version": "==2.0.1"
         },
+        "furo": {
+            "hashes": [
+                "sha256:958016bfe1387c1e8ddf5b9d71696b69c4eaa5cd8afc9492abfb008aba2d300c",
+                "sha256:b217f218cbcd423ffbfe69baa79389d4ecebf2d86f0d593c44ef31da7b5aed30"
+            ],
+            "index": "pypi",
+            "version": "==2022.1.2"
+        },
         "h11": {
             "hashes": [
-                "sha256:36a3cb8c0a032f56e2da7084577878a035d3b61d104230d4bd49c0c6b555a9c6",
-                "sha256:47222cb6067e4a307d535814917cd98fd0a57b6788ce715755fa2b6c28b56042"
+                "sha256:70813c1135087a248a4d38cc0e1a0181ffab2188141a93eaf567940c3957ff06",
+                "sha256:8ddd78563b633ca55346c8cd41ec0af27d3c79931828beffb46ce70a379e7442"
             ],
             "markers": "python_version >= '3.6'",
-            "version": "==0.12.0"
+            "version": "==0.13.0"
         },
         "idna": {
             "hashes": [
@@ -172,6 +211,14 @@
             "markers": "python_version >= '3'",
             "version": "==3.3"
         },
+        "imagesize": {
+            "hashes": [
+                "sha256:1db2f82529e53c3e929e8926a1fa9235aa82d0bd0c580359c67ec31b2fddaa8c",
+                "sha256:cd1750d452385ca327479d45b64d9c7729ecf0b3969a58148298c77092261f9d"
+            ],
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3'",
+            "version": "==1.3.0"
+        },
         "jinja2": {
             "hashes": [
                 "sha256:077ce6014f7b40d03b47d1f1ca4b0fc8328a692bd284016f806ed0eaca390ad8",
@@ -182,11 +229,11 @@
         },
         "loguru": {
             "hashes": [
-                "sha256:b28e72ac7a98be3d28ad28570299a393dfcd32e5e3f6a353dec94675767b6319",
-                "sha256:f8087ac396b5ee5f67c963b495d615ebbceac2796379599820e324419d53667c"
+                "sha256:066bd06758d0a513e9836fd9c6b5a75bfb3fd36841f4b996bc60b547a309d41c",
+                "sha256:4e2414d534a2ab57573365b3e6d0234dfb1d84b68b7f3b948e6fb743860a77c3"
             ],
             "index": "pypi",
-            "version": "==0.5.3"
+            "version": "==0.6.0"
         },
         "markupsafe": {
             "hashes": [
@@ -263,6 +310,14 @@
             "markers": "python_version >= '3.6'",
             "version": "==2.0.1"
         },
+        "packaging": {
+            "hashes": [
+                "sha256:dd47c42927d89ab911e606518907cc2d3a1f38bbd026385970643f9c5b8ecfeb",
+                "sha256:ef103e05f519cdc783ae24ea4e2e0f508a9c99b2d4969652eed6a2e1ea5bd522"
+            ],
+            "markers": "python_version >= '3.6'",
+            "version": "==21.3"
+        },
         "passlib": {
             "hashes": [
                 "sha256:aa6bca462b8d8bda89c70b382f0c298a20b5560af6cbfa2dce410c0a2fb669f1",
@@ -318,6 +373,14 @@
             ],
             "version": "==2.0.5"
         },
+        "pygments": {
+            "hashes": [
+                "sha256:44238f1b60a76d78fc8ca0528ee429702aae011c265fe6a8dd8b63049ae41c65",
+                "sha256:4e426f72023d88d03b2fa258de560726ce890ff3b630f88c21cbb8b2503b8c6a"
+            ],
+            "markers": "python_version >= '3.5'",
+            "version": "==2.11.2"
+        },
         "pyjwt": {
             "hashes": [
                 "sha256:b888b4d56f06f6dcd777210c334e69c737be74755d3e5e9ee3fe67dc18a0ee41",
@@ -326,6 +389,14 @@
             "markers": "python_version >= '3.6'",
             "version": "==2.3.0"
         },
+        "pyparsing": {
+            "hashes": [
+                "sha256:18ee9022775d270c55187733956460083db60b37d0d0fb357445f3094eed3eea",
+                "sha256:a6c06a88f252e6c322f65faf8f418b16213b51bdfaece0524c1c1bc30c63c484"
+            ],
+            "markers": "python_version >= '3.6'",
+            "version": "==3.0.7"
+        },
         "python-multipart": {
             "hashes": [
                 "sha256:f7bb5f611fc600d15fa47b3974c8aa16e93724513b49b5f95c81e6624c83fa43"
@@ -333,6 +404,13 @@
             "index": "pypi",
             "version": "==0.0.5"
         },
+        "pytz": {
+            "hashes": [
+                "sha256:3672058bc3453457b622aab7a1c3bfd5ab0bdae451512f6cf25f64ed37f5b87c",
+                "sha256:acad2d8b20a1af07d4e4c9d2e9285c5ed9104354062f275f3fcd88dcef4f1326"
+            ],
+            "version": "==2021.3"
+        },
         "requests": {
             "hashes": [
                 "sha256:68d7c56fd5a8999887728ef304a6d12edc7be74f1cfa47714fc8b414525c9a61",
@@ -357,6 +435,77 @@
             "markers": "python_version >= '3.5'",
             "version": "==1.2.0"
         },
+        "snowballstemmer": {
+            "hashes": [
+                "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1",
+                "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a"
+            ],
+            "version": "==2.2.0"
+        },
+        "soupsieve": {
+            "hashes": [
+                "sha256:1a3cca2617c6b38c0343ed661b1fa5de5637f257d4fe22bd9f1338010a1efefb",
+                "sha256:b8d49b1cd4f037c7082a9683dfa1801aa2597fb11c3a1155b7a5b94829b4f1f9"
+            ],
+            "markers": "python_version >= '3.6'",
+            "version": "==2.3.1"
+        },
+        "sphinx": {
+            "hashes": [
+                "sha256:5da895959511473857b6d0200f56865ed62c31e8f82dd338063b84ec022701fe",
+                "sha256:6caad9786055cb1fa22b4a365c1775816b876f91966481765d7d50e9f0dd35cc"
+            ],
+            "index": "pypi",
+            "version": "==4.4.0"
+        },
+        "sphinxcontrib-applehelp": {
+            "hashes": [
+                "sha256:806111e5e962be97c29ec4c1e7fe277bfd19e9652fb1a4392105b43e01af885a",
+                "sha256:a072735ec80e7675e3f432fcae8610ecf509c5f1869d17e2eecff44389cdbc58"
+            ],
+            "markers": "python_version >= '3.5'",
+            "version": "==1.0.2"
+        },
+        "sphinxcontrib-devhelp": {
+            "hashes": [
+                "sha256:8165223f9a335cc1af7ffe1ed31d2871f325254c0423bc0c4c7cd1c1e4734a2e",
+                "sha256:ff7f1afa7b9642e7060379360a67e9c41e8f3121f2ce9164266f61b9f4b338e4"
+            ],
+            "markers": "python_version >= '3.5'",
+            "version": "==1.0.2"
+        },
+        "sphinxcontrib-htmlhelp": {
+            "hashes": [
+                "sha256:d412243dfb797ae3ec2b59eca0e52dac12e75a241bf0e4eb861e450d06c6ed07",
+                "sha256:f5f8bb2d0d629f398bf47d0d69c07bc13b65f75a81ad9e2f71a63d4b7a2f6db2"
+            ],
+            "markers": "python_version >= '3.6'",
+            "version": "==2.0.0"
+        },
+        "sphinxcontrib-jsmath": {
+            "hashes": [
+                "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178",
+                "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"
+            ],
+            "markers": "python_version >= '3.5'",
+            "version": "==1.0.1"
+        },
+        "sphinxcontrib-qthelp": {
+            "hashes": [
+                "sha256:4c33767ee058b70dba89a6fc5c1892c0d57a54be67ddd3e7875a18d14cba5a72",
+                "sha256:bd9fc24bcb748a8d51fd4ecaade681350aa63009a347a8c14e637895444dfab6"
+            ],
+            "markers": "python_version >= '3.5'",
+            "version": "==1.0.3"
+        },
+        "sphinxcontrib-serializinghtml": {
+            "hashes": [
+                "sha256:352a9a00ae864471d3a7ead8d7d79f5fc0b57e8b3f95e9867eb9eb28999b92fd",
+                "sha256:aa5f6de5dfdf809ef505c4895e51ef5c9eac17d0f287933eb49ec495280b6952"
+            ],
+            "markers": "python_version >= '3.5'",
+            "version": "==1.1.5"
+        },
         "sqlobject": {
             "hashes": [
                 "sha256:45064184decf7f42d386704e5f47a70dee517d3e449b610506e174025f84d921",
@@ -461,14 +610,96 @@
         },
         "win32-setctime": {
             "hashes": [
-                "sha256:2b72b798fdc1d909fb3cc0d25e0be52a42f4848857e3588dd3947c6a18b42609",
-                "sha256:7964234073ad9bc7a689ef2ebe6ce931976b644fe73fd50cf7729c996b7d8385"
+                "sha256:15cf5750465118d6929ae4de4eb46e8edae9a5634350c01ba582df868e932cb2",
+                "sha256:231db239e959c2fe7eb1d7dc129f11172354f98361c4fa2d6d2d7e278baa8aad"
             ],
             "index": "pypi",
-            "version": "==1.0.4"
+            "version": "==1.1.0"
         }
     },
     "develop": {
+        "certifi": {
+            "hashes": [
+                "sha256:78884e7c1d4b00ce3cea67b44566851c4343c120abd683433ce934a68ea58872",
+                "sha256:d62a0163eb4c2344ac042ab2bdf75399a71a2d8c7d47eac2e2ee91b9d6339569"
+            ],
+            "version": "==2021.10.8"
+        },
+        "charset-normalizer": {
+            "hashes": [
+                "sha256:2842d8f5e82a1f6aa437380934d5e1cd4fcf2003b06fed6940769c164a480a45",
+                "sha256:98398a9d69ee80548c762ba991a4728bfc3836768ed226b3945908d1a688371c"
+            ],
+            "markers": "python_version >= '3'",
+            "version": "==2.0.11"
+        },
+        "coverage": {
+            "hashes": [
+                "sha256:01774a2c2c729619760320270e42cd9e797427ecfddd32c2a7b639cdc481f3c0",
+                "sha256:03b20e52b7d31be571c9c06b74746746d4eb82fc260e594dc662ed48145e9efd",
+                "sha256:0a7726f74ff63f41e95ed3a89fef002916c828bb5fcae83b505b49d81a066884",
+                "sha256:1219d760ccfafc03c0822ae2e06e3b1248a8e6d1a70928966bafc6838d3c9e48",
+                "sha256:13362889b2d46e8d9f97c421539c97c963e34031ab0cb89e8ca83a10cc71ac76",
+                "sha256:174cf9b4bef0db2e8244f82059a5a72bd47e1d40e71c68ab055425172b16b7d0",
+                "sha256:17e6c11038d4ed6e8af1407d9e89a2904d573be29d51515f14262d7f10ef0a64",
+                "sha256:215f8afcc02a24c2d9a10d3790b21054b58d71f4b3c6f055d4bb1b15cecce685",
+                "sha256:22e60a3ca5acba37d1d4a2ee66e051f5b0e1b9ac950b5b0cf4aa5366eda41d47",
+                "sha256:2641f803ee9f95b1f387f3e8f3bf28d83d9b69a39e9911e5bfee832bea75240d",
+                "sha256:276651978c94a8c5672ea60a2656e95a3cce2a3f31e9fb2d5ebd4c215d095840",
+                "sha256:3f7c17209eef285c86f819ff04a6d4cbee9b33ef05cbcaae4c0b4e8e06b3ec8f",
+                "sha256:3feac4084291642165c3a0d9eaebedf19ffa505016c4d3db15bfe235718d4971",
+                "sha256:49dbff64961bc9bdd2289a2bda6a3a5a331964ba5497f694e2cbd540d656dc1c",
+                "sha256:4e547122ca2d244f7c090fe3f4b5a5861255ff66b7ab6d98f44a0222aaf8671a",
+                "sha256:5829192582c0ec8ca4a2532407bc14c2f338d9878a10442f5d03804a95fac9de",
+                "sha256:5d6b09c972ce9200264c35a1d53d43ca55ef61836d9ec60f0d44273a31aa9f17",
+                "sha256:600617008aa82032ddeace2535626d1bc212dfff32b43989539deda63b3f36e4",
+                "sha256:619346d57c7126ae49ac95b11b0dc8e36c1dd49d148477461bb66c8cf13bb521",
+                "sha256:63c424e6f5b4ab1cf1e23a43b12f542b0ec2e54f99ec9f11b75382152981df57",
+                "sha256:6dbc1536e105adda7a6312c778f15aaabe583b0e9a0b0a324990334fd458c94b",
+                "sha256:6e1394d24d5938e561fbeaa0cd3d356207579c28bd1792f25a068743f2d5b282",
+                "sha256:86f2e78b1eff847609b1ca8050c9e1fa3bd44ce755b2ec30e70f2d3ba3844644",
+                "sha256:8bdfe9ff3a4ea37d17f172ac0dff1e1c383aec17a636b9b35906babc9f0f5475",
+                "sha256:8e2c35a4c1f269704e90888e56f794e2d9c0262fb0c1b1c8c4ee44d9b9e77b5d",
+                "sha256:92b8c845527eae547a2a6617d336adc56394050c3ed8a6918683646328fbb6da",
+                "sha256:9365ed5cce5d0cf2c10afc6add145c5037d3148585b8ae0e77cc1efdd6aa2953",
+                "sha256:9a29311bd6429be317c1f3fe4bc06c4c5ee45e2fa61b2a19d4d1d6111cb94af2",
+                "sha256:9a2b5b52be0a8626fcbffd7e689781bf8c2ac01613e77feda93d96184949a98e",
+                "sha256:a4bdeb0a52d1d04123b41d90a4390b096f3ef38eee35e11f0b22c2d031222c6c",
+                "sha256:a9c8c4283e17690ff1a7427123ffb428ad6a52ed720d550e299e8291e33184dc",
+                "sha256:b637c57fdb8be84e91fac60d9325a66a5981f8086c954ea2772efe28425eaf64",
+                "sha256:bf154ba7ee2fd613eb541c2bc03d3d9ac667080a737449d1a3fb342740eb1a74",
+                "sha256:c254b03032d5a06de049ce8bca8338a5185f07fb76600afff3c161e053d88617",
+                "sha256:c332d8f8d448ded473b97fefe4a0983265af21917d8b0cdcb8bb06b2afe632c3",
+                "sha256:c7912d1526299cb04c88288e148c6c87c0df600eca76efd99d84396cfe00ef1d",
+                "sha256:cfd9386c1d6f13b37e05a91a8583e802f8059bebfccde61a418c5808dea6bbfa",
+                "sha256:d5d2033d5db1d58ae2d62f095e1aefb6988af65b4b12cb8987af409587cc0739",
+                "sha256:dca38a21e4423f3edb821292e97cec7ad38086f84313462098568baedf4331f8",
+                "sha256:e2cad8093172b7d1595b4ad66f24270808658e11acf43a8f95b41276162eb5b8",
+                "sha256:e3db840a4dee542e37e09f30859f1612da90e1c5239a6a2498c473183a50e781",
+                "sha256:edcada2e24ed68f019175c2b2af2a8b481d3d084798b8c20d15d34f5c733fa58",
+                "sha256:f467bbb837691ab5a8ca359199d3429a11a01e6dfb3d9dcc676dc035ca93c0a9",
+                "sha256:f506af4f27def639ba45789fa6fde45f9a217da0be05f8910458e4557eed020c",
+                "sha256:f614fc9956d76d8a88a88bb41ddc12709caa755666f580af3a688899721efecd",
+                "sha256:f9afb5b746781fc2abce26193d1c817b7eb0e11459510fba65d2bd77fe161d9e",
+                "sha256:fb8b8ee99b3fffe4fd86f4c81b35a6bf7e4462cba019997af2fe679365db0c49"
+            ],
+            "index": "pypi",
+            "version": "==6.2"
+        },
+        "coveralls": {
+            "hashes": [
+                "sha256:b32a8bb5d2df585207c119d6c01567b81fba690c9c10a753bfe27a335bfc43ea",
+                "sha256:f42015f31d386b351d4226389b387ae173207058832fbf5c8ec4b40e27b16026"
+            ],
+            "index": "pypi",
+            "version": "==3.3.1"
+        },
+        "docopt": {
+            "hashes": [
+                "sha256:49b3a825280bd66b3aa83585ef59c4a8c82f2c8a522dbe754a8bc8d08c85c491"
+            ],
+            "version": "==0.6.2"
+        },
         "flake8": {
             "hashes": [
                 "sha256:479b1304f72536a55948cb40a32dce8bb0ffe3501e26eaf292c7e60eb5e0428d",
@@ -477,6 +708,14 @@
             "index": "pypi",
             "version": "==4.0.1"
         },
+        "idna": {
+            "hashes": [
+                "sha256:84d9dd047ffa80596e0f246e2eab0b391788b0503584e8945f2368256d2735ff",
+                "sha256:9d643ff0a55b762d5cdb124b8eaa99c66322e2157b69160bc32796e824360e6d"
+            ],
+            "markers": "python_version >= '3'",
+            "version": "==3.3"
+        },
         "mccabe": {
             "hashes": [
                 "sha256:ab8a6258860da4b6677da4bd2fe5dc2c659cff31b3ee4f7f5d64e79735b80d42",
@@ -500,6 +739,22 @@
             ],
             "index": "pypi",
             "version": "==2.4.0"
+        },
+        "requests": {
+            "hashes": [
+                "sha256:68d7c56fd5a8999887728ef304a6d12edc7be74f1cfa47714fc8b414525c9a61",
+                "sha256:f22fa1e554c9ddfd16e6e41ac79759e17be9e492b3587efa038054674760e72d"
+            ],
+            "index": "pypi",
+            "version": "==2.27.1"
+        },
+        "urllib3": {
+            "hashes": [
+                "sha256:000ca7f471a233c2251c6c7023ee85305721bfdf18621ebff4fd17a8653427ed",
+                "sha256:0e7c33d9a63e7ddfcb86780aac87befc2fbddf46c58dbb487e0855f7ceec283c"
+            ],
+            "markers": "python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3, 3.4' and python_version < '4.0'",
+            "version": "==1.26.8"
         }
     }
 }
diff --git a/README.md b/README.md
index d91cb8d7..40aefbdb 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,9 @@
 # Morelia Server - мессенджер (сервер) для Morelia Network #
 
+
+![tests](https://github.com/MoreliaTalk/morelia_server/workflows/Test%20and%20Linting/badge.svg)
+[![Coverage Status](https://coveralls.io/repos/github/MoreliaTalk/morelia_server/badge.svg?branch=develop-nekrod)](https://coveralls.io/github/MoreliaTalk/morelia_server)
+
 Language [EN](./README_ENG.md), [RU](./README.md)
 
 ## В репозитории 2 бранча ##
diff --git a/README_ENG.md b/README_ENG.md
index cc5fa842..890e69f2 100644
--- a/README_ENG.md
+++ b/README_ENG.md
@@ -1,5 +1,8 @@
 # Morelia Server - messenger server for Morelia Network #
 
+![tests](https://github.com/MoreliaTalk/morelia_server/workflows/Test%20and%20Linting/badge.svg)
+[![Coverage Status](https://coveralls.io/repos/github/MoreliaTalk/morelia_server/badge.svg?branch=develop-nekrod)](https://coveralls.io/github/MoreliaTalk/morelia_server)
+
 Language [EN](./README_ENG.md), [RU](./README.md)
 
 ## There are two brunches in repository ##
@@ -57,8 +60,6 @@ Language [EN](./README_ENG.md), [RU](./README.md)
 * example_config.ini - file containing example server settings, just rename it to `config.ini` before running the server.
 * client.py - mini-customer to test the server.
 
-Translated with www.DeepL.com/Translator (free version)
-
 ## Installing ##
 
 Install [Python](https://www.python.org/downloads/) version 3.8 or higher.
diff --git a/admin/admin.py b/admin/admin.py
index a57477b2..a35ad82e 100644
--- a/admin/admin.py
+++ b/admin/admin.py
@@ -26,7 +26,7 @@
 from starlette.responses import RedirectResponse
 
 from mod.db.dbhandler import DBHandler
-from mod.config import DATABASE
+from config import DATABASE
 from . import login
 from . import logs
 from . import control as manage
@@ -45,11 +45,32 @@
 @app.exception_handler(login.NotAuthenticatedException)
 def not_login_exception_handler(request: Request,
                                 exc: login.NotAuthenticatedException):
+    """
+    Catches exception login.NotAuthenticatedException and redirects the user to the login page("/admin/login/")
+
+    Args:
+        request(Request): request to the server
+        exc(login.NotAuthenticatedException): catchable user authentication error
+
+    Returns:
+        (RedirectResponse): redirect response to /admin/login
+    """
     return RedirectResponse(url="/admin/login")
 
 
 @app.get("/login")
 def login_admin(request: Request):
+    """
+    The function is triggered when a request is received for the /login address
+    and returns a response generated from login.html
+
+    Args:
+        request(Request): request to the server
+
+    Returns:
+        (templates.TemplateResponse): response generated from login.html template
+
+    """
     return templates.TemplateResponse("login.html", {
                                         "request": request
                                         })
@@ -58,6 +79,16 @@ def login_admin(request: Request):
 @app.get("/")
 def index_admin(request: Request,
                 user=Depends(login.login_manager)):
+    """
+    Returns a response with the main page of the admin panel
+
+    Args:
+        request(Request): request to the server
+        user: user authentication check
+
+    Returns:
+        (templates.TemplateResponse): response generated from index_admin.html template
+    """
     return templates.TemplateResponse("index_admin.html", {
                                         "request": request
                                         })
@@ -66,6 +97,16 @@ def index_admin(request: Request,
 @app.get("/status")
 def status_admin(request: Request,
                  user=Depends(login.login_manager)):
+    """
+        Returns a response with the status page of the admin panel
+
+        Args:
+            request(Request): request to the server
+            user: user authentication check
+
+        Returns:
+            (templates.TemplateResponse): response generated from status_admin.html template
+        """
     dbquery = db_connect.get_table_count()
     return templates.TemplateResponse("status_admin.html",
                                       {"request": request,
@@ -80,6 +121,16 @@ def status_admin(request: Request,
 @app.get("/manage")
 def manage_admin(request: Request,
                  user=Depends(login.login_manager)):
+    """
+        Returns a response with the mange page of the admin panel
+
+        Args:
+            request(Request): request to the server
+            user: user authentication check
+
+        Returns:
+            (templates.TemplateResponse): response generated from manage_admin.html template
+    """
     dbquery = db_connect.get_all_user()
     return templates.TemplateResponse("manage_admin.html", {
                                         "request": request,
@@ -90,6 +141,16 @@ def manage_admin(request: Request,
 @app.get("/logs")
 def manage_logs(request: Request,
                 user=Depends(login.login_manager)):
+    """
+        Returns a response with the logs view page of the admin panel
+
+        Args:
+            request(Request): request to the server
+            user: user authentication check
+
+        Returns:
+            (templates.TemplateResponse): response generated from logs_admin.html template
+    """
     return templates.TemplateResponse("logs_admin.html", {
                                         "request": request
                                         })
diff --git a/admin/control.py b/admin/control.py
index 93159095..9e74baf4 100644
--- a/admin/control.py
+++ b/admin/control.py
@@ -26,7 +26,7 @@
 from starlette.responses import HTMLResponse
 
 from mod.db.dbhandler import DBHandler
-from mod.config import DATABASE
+from config import DATABASE
 
 
 router = APIRouter()
@@ -37,6 +37,17 @@
 @router.post("/manage/delete_user")
 def delete_user(request: Request,
                 uuid: str = Form(...)):
+    """
+        The function receives the request and admin uuid, delete admin user,
+        and returns a response, redirecting to the main page of the admin panel
+
+        Args:
+            request(Request): request for server
+            uuid(str): uuid admin user
+
+        Returns:
+            (HTMLResponse): response redirecting to the main admin page
+    """
     fake_uuid = str(uuid4().int)
 
     db_connect.update_user(uuid=uuid,
diff --git a/admin/login.py b/admin/login.py
index 473ef7f5..441cd8df 100644
--- a/admin/login.py
+++ b/admin/login.py
@@ -27,8 +27,8 @@
 
 from mod import lib
 from mod.db.dbhandler import DBHandler
-from mod.config import DATABASE
-from mod.config import ADMIN
+from config import DATABASE
+from config import ADMIN
 
 
 db_connect = DBHandler(DATABASE.get('URI'))
@@ -37,6 +37,9 @@
 
 
 class NotAuthenticatedException(Exception):
+    """
+        An exception occurs when the user's authorization data is missing or incorrect
+    """
     pass
 
 
@@ -50,6 +53,15 @@ class NotAuthenticatedException(Exception):
 
 @login_manager.user_loader()
 def get_admin_user_data(username: str):
+    """
+    The function of requesting data from the database and checking it against the username, if there is valid data, it returns it
+
+    Args:
+        username(str): username admin user
+
+    Returns:
+        (SQLObject) - admin user data from db
+    """
     data = db_connect.get_admin_by_name(username=username)
     if data.count():
         return data[0]
@@ -57,6 +69,18 @@ def get_admin_user_data(username: str):
 
 @router.post("/login/token")
 def login_token(data: OAuth2PasswordRequestForm = Depends()):
+    """
+    The function receives the data
+    and returns a response that contains the admin token for the user,
+    valid for 15 minutes
+
+    Args:
+        data(OAuth2PasswordRequestForm): login data
+
+    Returns:
+        (HTMLResponse): response with cookies embedded in it
+    """
+
     admin_user_data_db = get_admin_user_data(data.username)
     if not admin_user_data_db:
         return HTMLResponse("""<script>
@@ -87,6 +111,16 @@ def login_token(data: OAuth2PasswordRequestForm = Depends()):
 
 @router.post("/login/logout")
 def logout(request: Request):
+    """
+        The function receives the request
+        and returns a response that contains the invalid admin token
+
+        Args:
+            request(Request): request for server
+
+        Returns:
+            (HTMLResponse): response with cookies embedded in it
+    """
     incorrect_token = "MoreliaTalk"
 
     response = HTMLResponse("""<script>
diff --git a/admin/logs.py b/admin/logs.py
index f2bb457e..b7817841 100644
--- a/admin/logs.py
+++ b/admin/logs.py
@@ -32,9 +32,25 @@
 @router.get("/logs/get")
 def get_logs(request: Request,
              user=Depends(login.login_manager)):
+    """
+        Returns a dict with server logs
+
+        Args:
+            request(Request): request to the server
+            user: user authentication check
+
+        Returns:
+            (dict)
+    """
     return {"logs": log_string}
 
 
-def loguru_handler(log):
+def loguru_handler(log: str):
+    """
+        Function collects server logs
+
+        Args:
+            log(str): new log string
+    """
     global log_string
     log_string += log
diff --git a/mod/config.py b/config.py
similarity index 94%
rename from mod/config.py
rename to config.py
index a2751989..f5c15353 100644
--- a/mod/config.py
+++ b/config.py
@@ -19,11 +19,12 @@
     along with Morelia Server. If not, see <https://www.gnu.org/licenses/>.
 """
 import configparser
+from pathlib import Path
 
 
 config = configparser.ConfigParser()
 
-config.read('config.ini')
+config.read(Path(__file__).parent / 'config.ini')
 
 LOGGING = config['LOGGING']
 DATABASE = config["DATABASE"]
diff --git a/docs/Makefile b/docs/Makefile
new file mode 100644
index 00000000..d0c3cbf1
--- /dev/null
+++ b/docs/Makefile
@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/docs/make.bat b/docs/make.bat
new file mode 100644
index 00000000..061f32f9
--- /dev/null
+++ b/docs/make.bat
@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd
diff --git a/docs/source/conf.py b/docs/source/conf.py
new file mode 100644
index 00000000..fa768d8b
--- /dev/null
+++ b/docs/source/conf.py
@@ -0,0 +1,76 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import sys
+
+source_path = os.path.split(os.path.abspath("."))
+doc_path = os.path.split(source_path[0])
+sys.path.insert(0, doc_path[0])
+
+# -- Project information -----------------------------------------------------
+
+project = 'MoreliaTalk Server'
+copyright = '2022, MoreliaTalk'
+author = 'MoreliaTalk'
+
+# The full version, including alpha/beta/rc tags
+release = '0.1'
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.duration',
+    'sphinx.ext.autodoc',
+    'sphinx.ext.autosummary',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.githubpages',
+]
+
+# Napoleon settings
+napoleon_google_docstring = True
+napoleon_numpy_docstring = False
+napoleon_include_init_with_doc = False
+napoleon_include_private_with_doc = True
+napoleon_include_special_with_doc = True
+napoleon_use_admonition_for_examples = False
+napoleon_use_admonition_for_notes = False
+napoleon_use_admonition_for_references = False
+napoleon_use_ivar = False
+napoleon_use_param = True
+napoleon_use_rtype = True
+napoleon_preprocess_types = True
+napoleon_type_aliases = None
+napoleon_attr_annotations = True
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = []
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'furo'
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
diff --git a/docs/source/development.rst b/docs/source/development.rst
new file mode 100644
index 00000000..e1138fca
--- /dev/null
+++ b/docs/source/development.rst
@@ -0,0 +1,177 @@
+Development
+***********
+
+.. _development:
+
+
+Git repository
+--------------
+
+Stable branch `master <https://github.com/MoreliaTalk/morelia_server/tree/master>`_
+
+Branch to add new functionality `develop <https://github.com/MoreliaTalk/morelia_server/tree/develop>`_
+
+
+Fork repository
+---------------
+
+.. _fork:
+
+If you are not on the GitHub project team, you must first fork the Morelia Server repository to yourself by going to
+`link <https://github.com/MoreliaTalk/morelia_server/fork>`_.
+
+
+Cloning a repository
+--------------------
+
+1. Clone repository to your local computer using command line:
+
+::
+
+ git clone https://github.com/{username}/morelia_server.git
+ cd morelia_server
+
+2. Switching to ``develop`` branch:
+
+::
+
+ git checkout develop
+
+3. Synchronizing your fork with original repository ``upstream`` Morelia Server:
+
+::
+
+ git remote add upstream https://github.com/MoreliaTalk/morelia_server.git
+
+
+4. Check if repository ``upstream`` appeared in the list of deleted repositories:
+
+::
+
+ git remote -v
+ > origin    https://github.com/{username}/morelia_server.git (fetch)
+ > origin    https://github.com/{username}/morelia_server.git (push)
+ > upstream  https://github.com/MoreliaTalk/morelia_server.git (fetch)
+ > upstream  https://github.com/MoreliaTalk/morelia_server.git (push)
+
+
+5. If using GitHub Desktop, select ``Clone repository...`` from ``File`` menu and follow instructions.
+
+
+Creating a pool-request
+-----------------------
+
+For making changes to development branch Morelia Server.
+
+1. Getting the latest changes from development branch Morelia Server:
+
+::
+
+ git pull upstream develop
+
+
+2. Sending changes to development branch of your fork:
+
+::
+
+ git push
+
+
+3. To create a pull-request, you need to go to `GitHub <https://www.github.com>`_, select your fork and click on
+``New pull request`` in right-hand menu, then select branch from which you want to push changes to Morelia Server
+development branch and click ``Create pull request``.
+
+
+Code style requirements
+-----------------------
+
+Before starting work, it is recommended that you read:
+
+* `PEP 8 - Python Code Writing Guide <https://pythonworld.ru/osnovy/pep-8-rukovodstvo-po-napisaniyu-koda-na-python.html>`_.
+
+* `Google style of comment and docstring <https://google.github.io/styleguide/pyguide.html#s3.8-comments-and-docstrings>`_
+
+Be sure to use a linter (flake8, pylint or similar).
+
+
+Writing and running tests
+-------------------------
+
+Built-in Unittest module is used to write tests.
+
+To run tests, run (replace asterisk with test name):
+
+::
+
+ pipenv run python -v ./tests/test_*.py
+
+
+Running the debugger
+--------------------
+
+To run debugger in a working server environment, through console
+
+::
+
+ python -m pdb ./debug_server.py
+
+
+To get help in debug mode:
+
+::
+
+ (pdb) help
+
+
+Repository description
+----------------------
+
+`/admin/templates` - templates of admin pages
+
+`/admin/admin.py` - admin.py
+
+`/admin/control.py` - control.py
+
+`/admin/login.py` - login.py
+
+`/admin/logs.py` - logs.py
+
+`/mod/db/dbhandler.py` - module is designed to perform queries to the database
+
+`/mod/db/models.py` - module is responsible for the description of database tables to work through OPM
+
+`/mod/protocol/matrix/api.py` - module is responsible for the description of API, as well as the validation of data.
+
+`/mod/protocol/matrix/worker.py` - implementation of the protocol
+
+`/mod/protocol/mtp/api.py` - module responsible for API description, as well as data validation.
+
+`/mod/protocol/worker.py` - module is responsible for implementing the methods described in `Morelia Protocol <https://github.com/MoreliaTalk/morelia_protocol/blob/master/README.md>`_.
+
+`/mod/error.py` - module is responsible for checking and generating responses with error codes.
+
+`/mod/controller.py` - module is responsible for processing requests according to the protocol type.
+
+`/mod/lib.py` - module is responsible for password hashing, comparing password with its hash sum, creating hash for ``auth_id``.
+
+`/mod/logging.py` - module configures logging.
+
+`/config.py` - module reads settings from config.ini
+
+`/static/` - static files
+
+`/server.py` - main server code
+
+`/manage.py` - database migration manager (creating and deleting database tables)
+
+`/tests/fixtures/` - json-files with preliminarily prepared data for tests
+
+`/tests/config.ini` - server config for the tests
+
+`/tests/test_*.py` - tests
+
+`/debug_server.py` - wrapper for server.py to debug through the ``pdb`` utility.
+
+`/example_config.ini` - file containing example server settings, just rename it to ``config.ini`` before running the server.
+
+`/client.py` - mini-customer to test the server.
diff --git a/docs/source/doc.rst b/docs/source/doc.rst
new file mode 100644
index 00000000..407a90c3
--- /dev/null
+++ b/docs/source/doc.rst
@@ -0,0 +1,231 @@
+Documentation
+*************
+
+.. _doc:
+
+Server
+======
+
+Server.py contains two function: ``server.home_page()`` processing server information output, and ``server.websocket_endpoint()``
+responds connections for clients.
+
+.. TODO: Should need to add description for server.py
+
+
+MTP protocol
+============
+
+Read fully description about stable version of **MTP** protocol to this `link <https://github.com/MoreliaTalk/morelia_protocol>`_.
+
+To work with MTP protocol server used ``protocol.mtp`` module which included these classes:
+
+* MTPErrorResponse
+
+* MTProtocol
+
+* Response
+
+* Request
+
+
+MTPErrorResponse
+----------------
+
+Class ``mod.protocol.mtp.worker.MTPErrorResponse`` return response object with validation:
+
+.. autoclass:: mod.protocol.mtp.worker.MTPErrorResponse
+   :members:
+   :private-members:
+   :undoc-members:
+
+
+MTProtocol
+----------
+
+Class ``mod.protocol.mtp.worker.MTProtocol`` processing all methods contains MTP protocol description:
+
+.. autoclass:: mod.protocol.mtp.worker.MTProtocol
+   :members:
+   :private-members:
+   :undoc-members:
+
+
+Validations Response
+--------------------
+
+Class ``mod.protocol.mtp.api.Response`` processing results of MTPProtocol methods with following validation and generate
+response in JSON format:
+
+.. autoclass:: mod.protocol.mtp.api.Response
+   :members: data, errors, type, jsonapi, meta
+   :no-private-members:
+   :no-special-members:
+   :undoc-members:
+
+
+Validations Request
+--------------------
+
+General description of the class ``mod.protocol.mtp.api.Request`` processing response received from clients with following
+validation and generate error code when response not corresponds protocol methods:
+
+.. autoclass:: mod.protocol.mtp.api.Request
+   :members: data, errors, type, jsonapi, meta
+   :no-private-members:
+   :no-special-members:
+   :undoc-members:
+
+
+Matrix protocol
+===============
+
+Read fully description about latest version of **Matrix** protocol to `this <https://spec.matrix.org/latest/>`_ link.
+
+
+MatrixProtocol
+--------------
+
+Class ``mod.protocol.matrix.worker.MatrixProtocol`` processing half methods contains Matrix protocol description:
+
+.. autoclass:: mod.protocol.matrix.worker.MatrixProtocol
+   :members:
+   :private-members:
+   :undoc-members:
+
+
+Validations Response
+--------------------
+
+General description of the class ``mod.protocol.matrix.api.Response`` processing results of MatrixProtocol methods with
+following validation and generate response in JSON format:
+
+
+
+Validations Request
+--------------------
+
+General description of the class ``mod.protocol.matrix.api.Request`` processing response received from clients with following
+validation and generate error code when response not corresponds protocol methods:
+
+
+
+Database
+========
+
+
+DBhandler
+---------
+
+Class ``mod.db.dbhandler.DBHandler`` high layer class has to work with database without query in raw SQL:
+
+.. autoclass:: mod.db.dbhandler.DBHandler
+   :members:
+   :private-members:
+   :undoc-members:
+
+
+Models
+------
+
+
+UserConfig
+++++++++++
+
+Description UserConfig table where saving user secure and personal information ``mod.db.models.UserConfig``:
+
+.. autoclass:: mod.db.models.UserConfig
+
+
+Flow
+++++
+
+Description Flow table where saving flow information ``mod.db.models.Flow``:
+
+.. autoclass:: mod.db.models.Flow
+
+
+Message
++++++++
+
+Description Message table where saving message information ``mod.db.models.Message``:
+
+.. autoclass:: mod.db.models.Message
+
+
+Admin
++++++
+
+Description Admin table where saving access rights for web administration panel ``mod.db.models.Admin``:
+
+.. autoclass:: mod.db.models.Admin
+
+
+Controller
+==========
+
+
+MainHandler
+-----------
+
+Class identifies and redirects requests with accordance type of protocol ``mod.controller.MainHandler``:
+
+.. autoclass:: mod.controller.MainHandler
+   :members:
+   :private-members:
+   :undoc-members:
+
+
+Error
+=====
+
+Contains several new error code which additional for standard HTTP error code.
+
+General description of the class ``mod.error.ServerStatus``:
+
+.. autoclass:: mod.error.ServerStatus
+
+
+Checking matching status code name and type of errors contains in class ``mod.error.ServerStatus`` or ``HTTPStatus``
+
+.. autofunction:: mod.error.check_error_pattern
+
+
+Additional module
+=================
+
+Admin
+-------
+
+``admin``
+
+.. autofunction:: admin.admin.index_admin
+.. autofunction:: admin.admin.login_admin
+.. autofunction:: admin.admin.manage_admin
+.. autofunction:: admin.admin.manage_logs
+.. autofunction:: admin.admin.status_admin
+.. autoexception:: admin.login.NotAuthenticatedException
+.. autofunction:: admin.admin.not_login_exception_handler
+.. autofunction:: admin.login.get_admin_user_data
+.. autofunction:: admin.login.login_token
+.. autofunction:: admin.login.logout
+.. autofunction:: admin.control.delete_user
+.. autofunction:: admin.logs.get_logs
+.. autofunction:: admin.logs.loguru_handler
+
+Hash
+----
+
+``mod.lib.Hash``:
+
+.. autoclass:: mod.lib.Hash
+   :members:
+   :private-members:
+   :undoc-members:
+
+
+Logging
+-------
+
+``mod.logging.add_logging()``:
+
+.. autofunction:: mod.logging.add_logging
\ No newline at end of file
diff --git a/docs/source/index.rst b/docs/source/index.rst
new file mode 100644
index 00000000..1d2e3e3a
--- /dev/null
+++ b/docs/source/index.rst
@@ -0,0 +1,56 @@
+.. morelia_server documentation master file, created by
+   sphinx-quickstart on Sat Jan 22 14:12:38 2022.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+MoreliaTalk server
+******************
+
+**MoreliaTalk server** - used to deploy the MoreliaTalk messenger infrastructure.
+
+
+Contacts
+========
+
+`Telegram <https://t.me/joinchat/LImHShzAmIWvpMxDTr5Vxw>`_ - a group where pressing issues are discussed.
+
+`Slack <www.moreliatalk.slack.com>`_ - an alternative way of discussing the project.
+
+
+For we development uses
+=======================
+
+* `Python 3.10 <https://www.python.org/>`_ - programming language
+
+* `FastAPI <https://fastapi.tiangolo.com>`_ - basic framework
+
+* `SQLObject <http://sqlobject.org>`_ - ORM for working with the database
+
+* `Pydantic <https://pydantic-docs.helpmanual.io>`_ - data validation
+
+* `Starlette <https://www.starlette.io>`_ - lightweight ASGI framework
+
+* `Websockets <https://pypi.org/project/websockets/>`_ - Python implementation of Websockets protocol (RFC 6455 & 7692)
+
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+Contents
+========
+
+.. toctree::
+
+   install
+   doc
+   development
+   licence
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
diff --git a/docs/source/install.rst b/docs/source/install.rst
new file mode 100644
index 00000000..a5b124b6
--- /dev/null
+++ b/docs/source/install.rst
@@ -0,0 +1,163 @@
+Install and Run
+***************
+
+
+Install
+-------
+
+.. _installation:
+
+* Install `Python <https://www.python.org/downloads/>`_ version 3.8 or higher.
+
+* Download and install the latest version `git <https://git-scm.com/downloads>`_.
+
+* If you need a GUI, install `GitHub Desktop <https://desktop.github.com/>`_.
+
+* Set up Git or GitHub Desktop by entering your ``username`` and ``email`` from an account created on `github <https://www.github.com>`_.
+
+
+Configuring the Pipenv
+----------------------
+
+To work with the project it is necessary to install the libraries that it uses and configure the so-called
+`virtual environment` or `virtualenv`, for this purpose the utility `Pipenv <https://github.com/pypa/pipenv>`_
+
+1. If pipenv is not installed, run:
+
+::
+
+ python -m pip install pipenv
+
+2. Create a virtual environment in project directory:
+
+::
+
+ pipenv shell
+
+3. Install all required libraries from Pipfile:
+
+::
+
+ pipenv install --ignore-pipfile
+
+
+Before starting the server
+--------------------------
+
+Before you start the server you need to make some settings (create a database, tables and add the first user - administrator)
+
+1. Create a database with empty tables:
+
+::
+
+ pipenv run python ./manage.py --db create
+
+
+2. If you want to delete all tables in the created database (**WARNING** only tables are deleted, the database is not deleted):
+
+::
+
+ pipenv run python ./manage.py --db delete
+
+
+3. Add the administrator in the created database:
+
+::
+
+ pipenv run python ./manage.py --table superuser
+
+
+4. Additionally, you can create a ``flow`` with the group type:
+
+::
+
+ pipenv run python ./manage.py --table flow
+
+
+5. Information about all the features of the configuration manager:
+
+::
+
+ pipenv run python ./manage.py --help
+
+
+Server startup
+--------------
+
+To start server, use command:
+
+::
+
+ uvicorn server:app --host 0.0.0.0 --port 8000 --reload --use-colors --http h11 --ws websockets
+
+
+Additional parameters that can be sent to server:
+
+--log-level <str>           Set the log level. Options: **critical**, **error**, **warning**, **info**, **debug**, **trace**.
+                            Default: **info**.
+--use-colors                Enable colorized formatting of the log records, in case this is not set it will be auto-detected.
+                            This option is ignored if the ``--log-config`` CLI option is used.
+--no-use-colors             Disable colorized formatting of the log records.
+--loop <str>                Set the event loop implementation. The uvloop implementation provides greater performance,
+                            but is not compatible with Windows or PyPy. Options: **auto**, **asyncio**, **uvloop**.
+                            Default: **auto**.
+--http <str>                Set the HTTP protocol implementation. The httptools implementation provides greater performance,
+                            but it is not compatible with PyPy, and requires compilation on Windows.
+                            Options: **auto**, **h11**, **httptools**. Default: **auto**.
+--ws <str>                  Set the WebSockets protocol implementation. Either of the websockets and wsproto packages are
+                            supported. Use **none** to deny all websocket requests. Options: **auto**, **none**, **websockets**,
+                            **wsproto**. Default: **auto**.
+--lifespan <str>            Set the Lifespan protocol implementation. Options: **auto**, **on**, **off**. Default: **auto**.
+--interface                 Select ASGI3, ASGI2, or WSGI as the application interface. Note that WSGI mode always disables
+                            WebSocket support, as it is not supported by the WSGI interface.
+                            Options: **auto**, **asgi3**, **asgi2**, **wsgi**. Default: **auto**.
+--limit-concurrency <int>   Maximum number of concurrent connections or tasks to allow, before issuing HTTP 503 responses.
+                            Useful for ensuring known memory usage patterns even under over-resourced loads.
+--limit-max-requests <int>  Maximum number of requests to service before terminating the process.
+                            Useful when running together with a process manager, for preventing memory leaks from impacting
+                            long-running processes.
+--backlog <int>             Maximum number of connections to hold in backlog. Relevant for heavy incoming traffic.
+                            Default: **2048**
+--ssl-keyfile <path>        SSL key file
+--ssl-certfile <path>       SSL certificate file
+--ssl-version <int>         SSL version to use (see stdlib ssl module's)
+--ssl-cert-reqs <int>       Whether client certificate is required (see stdlib ssl module's)
+--ssl-ca-certs <str>        CA certificates file
+--ssl-ciphers <str>         Ciphers to use (see stdlib ssl module's)
+--timeout-keep-alive <int>  Close Keep-Alive connections if no new data is received within this timeout. Default: 5.
+
+
+**DEBUG** mode
+--------------
+
+To easily start the server in debug mode, all you need to do is run `debug_server.py`:
+
+::
+
+ pipenv run python ./debug_server.py
+
+
+Working with built-in client
+----------------------------
+
+To test the server, run the mini client ``client.py`` in the console:
+
+::
+
+ pipenv run python -i ./client.py
+
+
+After launching, the client will send an authorization message (AUTH) to the server, the server's response will be displayed
+in the console, after which ``python`` will go into interactive line mode ``>>>``, so that it is possible to perform additional checks.
+
+In the interactive console, there will be one function available to send ``end_message`` which takes two arguments
+``message`` message and ``uri`` server address. In the argument ``message`` you need to pass an object with type *"dict"*
+or *"str"*, you can use ready-made examples of queries: **AUTH**, **GET_UPDATE**, **ADD_FLOW**, **ALL_FLOW**.
+In the argument you must pass an object with type *"str"*, you can use ready examples of server address: **LOCALHOST**.
+
+::
+
+ >>> send_message(GET_UPDATE, LOCALHOST)
+
+
+If no arguments are passed to the function, the default is to send an **AUTH** message to **LOCALHOST**.
diff --git a/docs/source/licence.rst b/docs/source/licence.rst
new file mode 100644
index 00000000..d6c8e9ca
--- /dev/null
+++ b/docs/source/licence.rst
@@ -0,0 +1,33 @@
+License
+*******
+
+Copyright (c) 2020 - present
+
+
+Current maintainers
++++++++++++++++++++
+
+`NekrodNIK <https://github.com/NekrodNIK>`_
+
+`Stepan Skriabin <https://github.com/stepanskryabin>`_
+
+`rus-ai <https://github.com/rus-ai>`_
+
+
+Following people have contributed their code to Morelia Server
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+`Hazzari <https://github.com/Hazzari>`_
+
+`xIMRANx <https://github.com/xIMRANx>`_
+
+
+Following people have contributed to Morelia Server
++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+`ma1ex <https://github.com/ma1ex>`_
+
+--------------
+
+Morelia Server is licensed under the GNU Lesser General Public License version 3 or later (LGPL-3.0-or-later).
+See the COPYING and COPYING.LESSER file for details.
diff --git a/example_config.ini b/example_config.ini
index 29502fb6..0347f90f 100644
--- a/example_config.ini
+++ b/example_config.ini
@@ -1,24 +1,3 @@
-"""
-    Copyright (c) 2021 - present NekrodNIK, Stepan Skriabin, rus-ai and other.
-    Look at the file AUTHORS.md(located at the root of the project) to get the
-    full list.
-
-    This file is part of Morelia Server.
-
-    Morelia Server is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Lesser General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    Morelia Server is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public License
-    along with Morelia Server. If not, see <https://www.gnu.org/licenses/>.
-"""
-
 [DATABASE]
 # Configuring database access
 # When URI is:
@@ -86,4 +65,4 @@ HASH_PASSWORD = 8b915f2f0b0d0ccf27854dd708524d0b5a91bdcd3775c6d3335f63d015a43ce1
 [ADMIN]
 # change in prodaction
 # command for generate secret_key(insert in console): python -c "import os; print(os.urandom(24).hex())"
-SECRET_KEY = 365fdb0a1dad5ba48518cfa63f407e9aae86b032cf34bd4b
\ No newline at end of file
+SECRET_KEY = 365fdb0a1dad5ba48518cfa63f407e9aae86b032cf34bd4a
\ No newline at end of file
diff --git a/mod/__init__.py b/mod/__init__.py
index 03929a75..66d4e3dd 100644
--- a/mod/__init__.py
+++ b/mod/__init__.py
@@ -17,4 +17,6 @@
 
     You should have received a copy of the GNU Lesser General Public License
     along with Morelia Server. If not, see <https://www.gnu.org/licenses/>.
-"""
\ No newline at end of file
+"""
+
+__all__ = ["controller", "error", "lib", "logging", "db", "protocol"]
diff --git a/mod/controller.py b/mod/controller.py
index aa14ab8a..162bb923 100644
--- a/mod/controller.py
+++ b/mod/controller.py
@@ -18,10 +18,8 @@
     You should have received a copy of the GNU Lesser General Public License
     along with Morelia Server. If not, see <https://www.gnu.org/licenses/>.
 """
-from time import time
+
 import json
-import secrets
-from collections import namedtuple
 
 from mod.db.dbhandler import DBHandler
 from mod.protocol.mtp.worker import MTProtocol
@@ -35,8 +33,9 @@ class MainHandler:
     Args:
         request (object): JSON request from websocket client
         database (DBHandler): object - database connection point
-        protocol (str): name of using protocol
+        protocol (str): name of using protocol, 'mtp' or 'matrix'.
     """
+
     def __init__(self,
                  request,
                  database: DBHandler,
@@ -51,14 +50,37 @@ def __init__(self,
             self.response = self.mtp_handler()
 
     def get_response(self):
+        """
+        Returns the result of the request processing depending on the protocol
+
+        Returns:
+                (json)
+        """
+
         return self.response
 
     def mtp_handler(self) -> json:
+        """
+        Returns the result of the get_response method of the class handling
+        the MTP protocol
+
+        Returns:
+            (json):
+        """
+
         result = MTProtocol(self.request,
                             self.database).get_response()
         return result
 
     def matrix_handler(self) -> json:
+        """
+        Returns the result of the get_response method of the class handling
+        the Matrix protocol
+
+        Returns:
+            (json):
+        """
+
         result = MatrixProtocol(self.request,
                                 self.database).get_response()
         return result
diff --git a/mod/db/dbhandler.py b/mod/db/dbhandler.py
index 70906c66..6519f867 100644
--- a/mod/db/dbhandler.py
+++ b/mod/db/dbhandler.py
@@ -18,6 +18,7 @@
     You should have received a copy of the GNU Lesser General Public License
     along with Morelia Server. If not, see <https://www.gnu.org/licenses/>.
 """
+
 import sys
 import inspect
 from collections import namedtuple
@@ -33,32 +34,41 @@
 
 
 class DatabaseReadError(SQLObjectNotFound):
-    pass
+    """
+    Occurs when there is no table in the database, there was a problem at
+    the stage of reading from database.
+    """
 
 
 class DatabaseAccessError(Exception):
-    pass
+    """
+    Occurs when there is an unknown problem when reading from database.
+    """
 
 
 class DatabaseWriteError(SQLObjectNotFound):
-    pass
+    """
+    Occurs when there is an unknown problem when writing to database.
+    """
 
 
 class DBHandler:
     """
-    A layer for interaction with the database.
-    As a method prescribed frequently used actions with data from the database.
+    A layer for interaction with the database ORM.
+    As a method prescribed frequently used actions with data from database.
 
     Args:
-        uri (str): like that [name of DB-API]:/:[directory or url or 'memory']:
+        uri (str): [name of DB-API]:/:[directory or url or 'memory'] like that
+                   sqlite:/:memory:
         debug (bool): enable or disable debug messages
         logger (str): name of logger
         loglevel (str): standard logging levels: info, debug, error.
-            Or stderr, stdout
+                        or stderr, stdout
         path_to_models (str): path to the location of the file describing
-            database tables
+                              database tables
 
     """
+
     def __init__(self,
                  uri: str = 'sqlite:/:memory:',
                  debug: bool = False,
@@ -85,32 +95,64 @@ def __init__(self,
         self.path = path_to_models
 
     def __str__(self) -> str:
+        """
+        Returned string which contains URI for connected database.
+
+        Returns:
+            (str): Connected to database: URI
+        """
+
         return f"Connected to database: {self._uri}"
 
     def __repr__(self) -> str:
-        return "".join((f"class {self.__class__.__name__}: ",
+        """
+        Return string which contains name of created class and parameters send
+        to class object when is created.
+
+        Returns:
+            (str): Class __name__: debug=, logger=, loglevel=
+        """
+
+        return "".join((f"Class {self.__class__.__name__}: ",
                         f"debug={self._debug} ",
                         f"logger={self._logger} ",
                         f"loglevel={self._loglevel}"))
 
     def __search_db_in_models(self) -> tuple:
+        """
+        Search all class name which contains in models.py
+
+        Returns:
+            (tuple): name of table
+        """
+
         classes = [cls_name for cls_name, cls_obj
                    in inspect.getmembers(sys.modules[self.path])
                    if inspect.isclass(cls_obj)]
         return tuple(classes)
 
     def create_table(self) -> None:
-        # looking for all Classes listed in models.py
+        """
+        Create all table which contains in models.py
+
+        Returns:
+            (None):
+        """
+
         for item in self.__search_db_in_models():
-            # Create tables in database for each class
-            # that is located in models module
             class_ = getattr(models, item)
             class_.createTable(ifNotExists=True,
                                connection=self.connection)
         return
 
     def delete_table(self) -> None:
-        # looking for all Classes listed in models.py
+        """
+        Delete all table which contains in models.py
+
+        Returns:
+            (None):
+        """
+
         for item in self.__search_db_in_models():
             class_ = getattr(models, item)
             class_.dropTable(ifExists=True,
@@ -121,6 +163,13 @@ def delete_table(self) -> None:
 
     @property
     def debug(self) -> bool | None:
+        """
+        Shows is flag set in property `debug`.
+
+        Returns:
+            (bool): True or False
+        """
+
         if self._debug == "0":
             return False
         else:
@@ -129,6 +178,16 @@ def debug(self) -> bool | None:
     @debug.setter
     def debug(self,
               value: bool = False) -> None:
+        """
+        Set `debug` property.
+
+        Args:
+            value (bool): True or False
+
+        Returns:
+            (None):
+        """
+
         if value is True:
             self._debug = "1"
         self._uri = "".join((self._uri,
@@ -140,6 +199,27 @@ def __read_db(self,
                   table: str,
                   get_one: bool,
                   **kwargs) -> SelectResults | SQLObject:
+        """
+        Universal method for read data in database.
+
+        Args:
+            table (str): name of table
+            get_one (str): sets how many objects will be returned, True for one
+                           object or False for many object
+            **kwargs (str): dict contains name of column and data
+
+        Returns:
+            (SelectResult | SQLObject): ORM object contains one or many row
+                                        from database
+
+        Raises:
+            DatabaseReadError: occurs when there is no table in the database,
+                               there was a problem at the stage of reading from
+                               database
+            DatabaseAccessError: occurs when there is an unknown problem when
+                                 reading from database
+        """
+
         # The SelectResults object type when the result
         # is in the form of a list. SQLObject type when
         # the result is a single object.
@@ -168,6 +248,21 @@ def __read_db(self,
     @staticmethod
     def __write_db(table: str,
                    **kwargs) -> SQLObject:
+        """
+        Universal method for write data in database.
+
+        Args:
+            table (str): name of table
+            **kwargs (str): dict contains name of column and data
+
+        Returns:
+            (SQLObject):
+
+        Raises:
+            DatabaseWriteError: occurs when there is an unknown problem when
+                                writing to database
+        """
+
         db = getattr(models, table)
         try:
             dbquery = db(**kwargs)
@@ -177,17 +272,43 @@ def __write_db(table: str,
             return dbquery
 
     def get_all_user(self) -> SelectResults:
+        """
+        Gives out all user contains in UserConfig table.
+
+        Returns:
+            (SelectResult):
+        """
+
         return self.__read_db(table="UserConfig",
                               get_one=False)
 
     def get_user_by_uuid(self,
                          uuid: str) -> SQLObject:
+        """
+        Gives out user by uuid contains in UserConfig table.
+
+        Args:
+            uuid(str): unique user identify number
+
+        Returns:
+            (SQLObject):
+        """
+
         return self.__read_db(table="UserConfig",
                               get_one=True,
                               uuid=uuid)
 
     def get_user_by_login(self,
                           login: str) -> SQLObject:
+        """
+        Gives out user by login contains in UserConfig table.
+        Args:
+            login (str): user login
+
+        Returns:
+            (SQLObject):
+        """
+
         return self.__read_db(table="UserConfig",
                               get_one=True,
                               login=login)
@@ -195,6 +316,17 @@ def get_user_by_login(self,
     def get_user_by_login_and_password(self,
                                        login: str,
                                        password: str) -> SQLObject:
+        """
+        Gives out user by login and password contains in UserConfig table.
+
+        Args:
+            login (str): user login
+            password (str): user password
+
+        Returns:
+            (SQLObject):
+        """
+
         return self.__read_db(table="UserConfig",
                               get_one=True,
                               login=login,
@@ -208,11 +340,34 @@ def add_user(self,
                  username: str = None,
                  is_bot: bool = False,
                  auth_id: str = None,
+                 token_ttl: int = None,
                  email: str = None,
                  avatar: bytes = None,
                  bio: str = None,
                  salt: bytes = None,
                  key: bytes = None) -> SQLObject:
+        """
+        Added new user to the UserConfig table,
+        if salt or key is None then used blank string converted to bytes.
+
+        Args:
+            uuid (str): unique user identify number
+            login (str): user login
+            password (str): user password
+            hash_password (str): hash from password
+            username (str): public username
+            is_bot (bool): type of user
+            auth_id (str): authenticate token
+            email (str): user email
+            avatar (bytes): user image or photo
+            bio (str): text information about user
+            salt (bytes): secret bytes string
+            key (bytes): secrets bytes string
+
+        Returns:
+            (SQLObject):
+        """
+
         if salt is None:
             salt = b''
 
@@ -227,6 +382,7 @@ def add_user(self,
                                username=username,
                                is_bot=is_bot,
                                auth_id=auth_id,
+                               token_ttl=token_ttl,
                                email=email,
                                avatar=avatar,
                                bio=bio,
@@ -241,11 +397,33 @@ def update_user(self,
                     username: str = None,
                     is_bot: bool = False,
                     auth_id: str = None,
+                    token_ttl: int = None,
                     email: str = None,
                     avatar: bytes = None,
                     bio: str = None,
                     key: bytes = None,
                     salt: bytes = None) -> str:
+        """
+        Updating information in the table UserConfig
+
+        Args:
+            uuid (str): unique user identify number
+            login (str): user login
+            password (str): user password
+            hash_password (str): hash from password
+            username (str): public username
+            is_bot (bool): type of user
+            auth_id (str): authenticate token
+            email (str): user email
+            avatar (bytes): user image or photo
+            bio (str): text information about user
+            salt (bytes): secret bytes string
+            key (bytes): secrets bytes string
+
+        Returns:
+            (str): message "Updated"
+
+        """
         dbquery = self.__read_db(table="UserConfig",
                                  get_one=True,
                                  uuid=uuid)
@@ -267,6 +445,9 @@ def update_user(self,
         if auth_id:
             dbquery.auth_id = auth_id
 
+        if token_ttl:
+            dbquery.token_ttl = token_ttl
+
         if email:
             dbquery.email = email
 
@@ -285,36 +466,105 @@ def update_user(self,
         return "Updated"
 
     def get_all_message(self) -> SelectResults:
+        """
+        Gives out all message contains Message table.
+
+        Returns:
+            (SelectResults):
+        """
+
         return self.__read_db(table="Message",
                               get_one=False)
 
     def get_message_by_uuid(self,
                             uuid: str) -> SQLObject:
+        """
+        Gives out one message by uuid which contains in Message table.
+
+        Args:
+            uuid(str): unique user identify number
+
+        Returns:
+            (SQLObject):
+        """
+
         return self.__read_db(table="Message",
                               get_one=True,
                               uuid=uuid)
 
     def get_message_by_text(self,
                             text: str) -> SelectResults:
+        """
+        Gives out all message which contains in Message table and contain
+        desired text string.
+
+        Args:
+            text (str): text string to be found
+
+        Returns:
+            (SelectResults):
+        """
+
         return self.__read_db(table="Message",
                               get_one=False,
                               text=text)
 
     @staticmethod
     def get_message_by_exact_time(time: int) -> SelectResults:
+        """
+        Gives out message by time, full compliance for requested time.
+
+        Args:
+            time (str): Unix-like time
+
+        Returns:
+            (SelectResults):
+        """
+
         return models.Message.select(models.Message.q.time == time)
 
     @staticmethod
     def get_message_by_less_time(time: int) -> SelectResults:
+        """
+        Gives out message by time, <= requested time.
+
+        Args:
+            time (str): Unix-like time
+
+        Returns:
+            (SelectResults):
+        """
+
         return models.Message.select(models.Message.q.time <= time)
 
     @staticmethod
     def get_message_by_more_time(time: int) -> SelectResults:
+        """
+        Gives out message by time, >= requested time.
+
+        Args:
+            time (str): Unix-like time
+
+        Returns:
+            (SelectResults):
+        """
+
         return models.Message.select(models.Message.q.time >= time)
 
     def get_message_by_more_time_and_flow(self,
                                           flow_uuid: str,
                                           time: int) -> SelectResults:
+        """
+        Gives out message by flow and time >= than requested.
+
+        Args:
+            flow_uuid (str): unique identify number from flow
+            time (int): Unix-like time
+
+        Returns:
+            (SelectResults):
+        """
+
         flow = self.__read_db(table="Flow",
                               get_one=True,
                               uuid=flow_uuid)
@@ -325,6 +575,17 @@ def get_message_by_more_time_and_flow(self,
     def get_message_by_less_time_and_flow(self,
                                           flow_uuid: str,
                                           time: int) -> SelectResults:
+        """
+        Gives out message by flow and time, <= requested time.
+
+        Args:
+            flow_uuid (str): unique identify number from flow
+            time (int): Unix-like time
+
+        Returns:
+            (SelectResults):
+        """
+
         flow = self.__read_db(table="Flow",
                               get_one=True,
                               uuid=flow_uuid)
@@ -335,6 +596,17 @@ def get_message_by_less_time_and_flow(self,
     def get_message_by_exact_time_and_flow(self,
                                            flow_uuid: str,
                                            time: int) -> SelectResults:
+        """
+        Gives out message by flow and time, full compliance for requested time.
+
+        Args:
+            flow_uuid (str): unique identify number from flow
+            time (int): Unix-like time
+
+        Returns:
+            (SelectResults):
+        """
+
         flow = self.__read_db(table="Flow",
                               get_one=True,
                               uuid=flow_uuid)
@@ -353,6 +625,29 @@ def add_message(self,
                     audio: bytes = None,
                     document: bytes = None,
                     emoji: bytes = None) -> SQLObject:
+        """
+        Added new message to the Message table.
+
+        Notes:
+            Before adding a message to the "Message" table, the presence of
+            "flow" and "user" in the database is checked.
+
+        Args:
+            flow_uuid (str): unique identify number from flow
+            user_uuid (str): unique user identify number
+            message_uuid (str): unique identify number from message
+            time (int): Unix-like time
+            text (str): message text
+            picture (bytes): appending image
+            video (bytes): appending video
+            audio (bytes): appending audio
+            document (bytes): appending document
+            emoji (bytes): appending emoji image
+
+        Returns:
+            (SQLObject):
+        """
+
         flow = self.__read_db(table="Flow",
                               get_one=True,
                               uuid=flow_uuid)
@@ -383,6 +678,25 @@ def update_message(self,
                        emoji: bytes = None,
                        edited_time: int = None,
                        edited_status: bool = False) -> str:
+        """
+        Update message content which contains in Message table.
+
+        Args:
+            uuid (str): unique identify number from message
+            text (str): message text
+            picture (bytes): appending image
+            video (bytes): appending video
+            audio (bytes): appending audio
+            document (bytes): appending document
+            emoji (bytes): appending emoji image
+            edited_time (int): time when user last time is corrected his
+                               message
+            edited_status (bool): True if user corrected his message
+
+        Returns:
+            (str): message "Updated"
+        """
+
         dbquery = self.__read_db(table="Message",
                                  get_one=True,
                                  uuid=uuid)
@@ -413,31 +727,88 @@ def update_message(self,
         return "Updated"
 
     def get_all_flow(self) -> SelectResults:
+        """
+        Gives out all flow from Flow table.
+
+        Returns:
+            (SelectResults):
+        """
+
         return self.__read_db(table="Flow",
                               get_one=False)
 
     def get_flow_by_uuid(self,
                          uuid: str) -> SQLObject:
+        """
+        Gives out one flow by uuid from Flow table.
+
+        Args:
+            uuid (str): unique user identify number
+
+        Returns:
+            (SQLObject):
+        """
+
         return self.__read_db(table="Flow",
                               get_one=True,
                               uuid=uuid)
 
     def get_flow_by_title(self,
                           title: str) -> SelectResults:
+        """
+        Gives out flow by title which contains in Flow table.
+
+        Args:
+            title (str): name added in public information about flow
+
+        Returns:
+            (SelectResults):
+        """
+
         return self.__read_db(table="Flow",
                               get_one=False,
                               title=title)
 
     @staticmethod
     def get_flow_by_more_time(time: int) -> SelectResults:
+        """
+        Gives flow by time, full compliance requested time.
+
+        Args:
+            time (int): Unix-like time
+
+        Returns:
+            (SelectResults):
+        """
+
         return models.Flow.select(models.Flow.q.time_created >= time)
 
     @staticmethod
     def get_flow_by_less_time(time: int) -> SelectResults:
+        """
+        Gives out flow by time <= requested time.
+
+        Args:
+            time (int): Unix-like time
+
+        Returns:
+            (SelectResults):
+        """
+
         return models.Flow.select(models.Flow.q.time_created <= time)
 
     @staticmethod
     def get_flow_by_exact_time(time: int) -> SelectResults:
+        """
+        Gives out floe by time == requested time.
+
+        Args:
+            time (int): Unix-like time
+
+        Returns:
+            (SelectResults):
+        """
+
         return models.Flow.select(models.Flow.q.time_created == time)
 
     def add_flow(self,
@@ -448,6 +819,22 @@ def add_flow(self,
                  title: str = None,
                  info: str = None,
                  owner: str = None) -> SQLObject:
+        """
+        Added new flow to the Flow table.
+
+        Args:
+            uuid (str): unique identify number from flow
+            users (list | tuple): uuid user which used that flow
+            time_created (int): time when created flow
+            flow_type (str): ``chat`` or ``group`` or ``channel``
+            title (str): name added in public information about flow
+            info (str): text added in public information about flow
+            owner (str): user uuid which created that flow
+
+        Returns:
+            (SQLObject):
+        """
+
         dbquery = self.__write_db(table="Flow",
                                   uuid=uuid,
                                   time_created=time_created,
@@ -467,6 +854,20 @@ def update_flow(self,
                     title: str = None,
                     info: str = None,
                     owner: str = None) -> str:
+        """
+        Update information about flow which contains in Flow table.
+
+        Args:
+            uuid (str): unique identify number from flow
+            flow_type (str): ``chat`` or ``group`` or ``channel``
+            title (str): name added in public information about flow
+            info (str): text added in public information about flow
+            owner (str): user uuid which created that flow
+
+        Returns:
+            (str): message "Updated"
+        """
+
         dbquery = self.__read_db(table="Flow",
                                  get_one=True,
                                  uuid=uuid)
@@ -486,6 +887,19 @@ def update_flow(self,
         return "Updated"
 
     def get_table_count(self) -> namedtuple:
+        """
+        Gives out quantity all row from Message, Flow or UserConfig table.
+
+        Returns:
+            (namedtuple): where
+
+                          ``user_count`` - quantity all UserConfig row
+
+                          ``flow_count`` - quantity all Flow row
+
+                          ``message_count`` - quantity all Message row
+        """
+
         TableCount = namedtuple('TableCount', ["user_count",
                                                "flow_count",
                                                "message_count"])
@@ -500,11 +914,28 @@ def get_table_count(self) -> namedtuple:
                           message.count())
 
     def get_all_admin(self) -> SelectResults:
+        """
+        Gives out all users from Admin table.
+
+        Returns:
+            (SelectResults):
+        """
+
         return self.__read_db(table="Admin",
                               get_one=False)
 
     def get_admin_by_name(self,
                           username: str) -> SQLObject:
+        """
+        Gives user by name from Admin table.
+
+        Args:
+            username (str): name user which granted administrator rights
+
+        Returns:
+            (SQLObject):
+        """
+
         return self.__read_db(table="Admin",
                               get_one=True,
                               username=username)
@@ -512,6 +943,18 @@ def get_admin_by_name(self,
     def add_admin(self,
                   username: str,
                   hash_password: str) -> SQLObject:
+        """
+        Added new admin to the Admin table.
+
+        Args:
+            username (str): name user which granted administrator rights
+            hash_password (str): hash-function generated from administrator
+                                 password
+
+        Returns:
+            (SQLObject):
+        """
+
         return self.__write_db(table="Admin",
                                username=username,
                                hash_password=hash_password)
diff --git a/mod/db/models.py b/mod/db/models.py
index 87ac58bf..3edf50dd 100644
--- a/mod/db/models.py
+++ b/mod/db/models.py
@@ -22,26 +22,26 @@
 
 
 class UserConfig(orm.SQLObject):
-    """Generates a table containing data
-    about user and his settings.
+    """
+    Table containing data about user and his settings.
 
     Args:
-        uuid (str, required, unique)
-        login (str, required)
-        password (str, required)
-        hash_password (str, optional): default None
-        username (str, optional): default None
-        is_bot (bool, optional): default False
-        auth_id (str, optional): default None
-        email (str, optional): default None
-        avatar (str, optional): default None
-        bio (str, optional): default None
-        salt (str, optional): default None
-        key (str, optional): default None
-
-    Returns:
-        None
+        uuid (str, required, unique): unique user id which automated
+                                      generating server
+        login (str, required): name for authentication on server
+        password (str, required): password for authentication on server
+        hash_password (str, optional): hash-function generated from user
+                                       password
+        username (str, optional): name for added in information about user
+        is_bot (bool, optional): True if user not human
+        auth_id (str, optional): authentication token
+        email (str, optional): user email for added in information about user
+        avatar (str, optional): user image for added in information about user
+        bio (str, optional): text for added in information about user
+        salt (str, optional): added in password string for create hash_password
+        key (str, optional): added in password string for create hash_password
     """
+
     uuid = orm.StringCol(notNone=True, unique=True)
     login = orm.StringCol(notNone=True)
     password = orm.StringCol(notNone=True)
@@ -49,6 +49,7 @@ class UserConfig(orm.SQLObject):
     username = orm.StringCol(default=None)
     is_bot = orm.BoolCol(default=False)
     auth_id = orm.StringCol(default=None)
+    token_ttl = orm.IntCol(default=None)
     email = orm.StringCol(default=None)
     avatar = orm.BLOBCol(default=None)
     bio = orm.StringCol(default=None)
@@ -60,19 +61,19 @@ class UserConfig(orm.SQLObject):
 
 
 class Flow(orm.SQLObject):
-    """Generates a Flow table containing information
-    about threads and their types (chat, channel, group).
+    """
+    Flow table containing information about threads and their types
+    (chat, channel, group).
 
     Args:
-        uuid (str, required, unique)
-        time_created (int, optional): default None
-        flow_type (str, optional): default None
-        title (str, optional): default None
-        info (str, optional): default None
-
-    Returns:
-        None
+        uuid (str, required, unique): unique flow id which automated
+                                      generating server
+        time_created (int, optional): data and time when flow is created
+        flow_type (str, optional): which contains chat, channel, group
+        title (str, optional): name added in public information about flow
+        info (str, optional): text added in public information about flow
     """
+
     uuid = orm.StringCol(notNone=True, unique=True)
     time_created = orm.IntCol(default=None)
     flow_type = orm.StringCol(default=None)
@@ -85,24 +86,25 @@ class Flow(orm.SQLObject):
 
 
 class Message(orm.SQLObject):
-    """Generates a Message table containing information
+    """
+    Generates a Message table containing information
     about user messages.
 
     Args:
-        uuid (str, required, unique):
-        text (str, optional): default None
-        time (int, optional): default None
-        file_picture (byte, optional): default None
-        file_video (byte, optional): default None
-        file_audio (byte, optional): default None
-        file_document (byte, optional): default None
-        emoji (str, optional): default None
-        edited_time (int, optional): default None
-        edited_status (bool, optional): default False
-
-    Returns:
-        None
+        uuid (str, required, unique): unique flow id which automated
+                                      generating server
+        text (str, optional): contains message text
+        time (int, optional): time when message is created
+        file_picture (byte, optional): contains appended image
+        file_video (byte, optional): contains appended video
+        file_audio (byte, optional): contains appended audio
+        file_document (byte, optional): contains appended document
+        emoji (str, optional): contains appended image/emoji
+        edited_time (int, optional): time when user last time is corrected his
+                                     message
+        edited_status (bool, optional): True if user corrected his message
     """
+
     uuid = orm.StringCol(notNone=True, unique=True)
     text = orm.StringCol(default=None)
     time = orm.IntCol(default=None)
@@ -119,15 +121,16 @@ class Message(orm.SQLObject):
 
 
 class Admin(orm.SQLObject):
-    """Generates a Admin table containing information
-        about users with administrators role.
+    """
+    Generates Admin table containing information
+    about users with administrators role.
 
-        Args:
-            username (str, required, unique)
-            hash_password (str, required)
+    Args:
+        username (str, required, unique): name user which granted administrator
+                                          rights
+        hash_password (str, required): hash-function generated from
+                                       administrator password
+    """
 
-        Returns:
-            None
-        """
     username = orm.StringCol(notNone=True, unique=True)
     hash_password = orm.StringCol(notNone=True)
diff --git a/mod/error.py b/mod/error.py
index 4997b5ae..734a3315 100644
--- a/mod/error.py
+++ b/mod/error.py
@@ -24,8 +24,18 @@
 
 
 class ServerStatus(IntEnum):
-    """Additional server status code and reason phrases
     """
+    Additional server status code and reason phrases
+
+    Notes:
+        CLIENT_CLOSED_REQUEST - 499
+
+        UNKNOWN_ERROR - 520
+
+        INVALID_SSL_CERTIFICATE - 526
+
+    """
+
     def __new__(cls, value, phrase, description=''):
         obj = int.__new__(cls, value)
         obj._value_ = value
@@ -36,6 +46,9 @@ def __new__(cls, value, phrase, description=''):
     CLIENT_CLOSED_REQUEST = (499,
                              'Client Closed Request',
                              'Full description: Client Closed Request')
+    VERSION_NOT_SUPPORTED = (505,
+                             'Version Not Supported',
+                             'Cannot fulfill request')
     UNKNOWN_ERROR = (520,
                      'Unknown Error',
                      'Full description: Unknown Error')
@@ -45,6 +58,24 @@ def __new__(cls, value, phrase, description=''):
 
 
 def check_error_pattern(status: str) -> namedtuple:
+    """
+    Checks the error name against the existing error types supported by
+    the server. The error name is passed as a "status" parameter.
+
+    Args:
+        status (str): error name
+
+    Returns:
+        (namedtuple): named tuple with three value, where
+
+                        ``value`` - status code of error
+
+                        ``phrase`` - status name of error
+
+                        ``description`` - short description of the error
+
+    """
+
     CatchError = namedtuple('CatchError', ['code',
                                            'status',
                                            'detail'])
diff --git a/mod/lib.py b/mod/lib.py
index ffbe18ec..2ec0fcde 100644
--- a/mod/lib.py
+++ b/mod/lib.py
@@ -24,30 +24,29 @@
 from hmac import compare_digest
 from os import urandom
 
-from mod.config import HASH_SIZE
+from config import HASH_SIZE
 
 
 class Hash:
-    """Generates password hashes, hashes for sessions,
-    authenticator ID's, checks passwords hashes.
+    """
+    Generates password hashes, hashes for sessions, authenticator token,
+    checks password hashes.
 
     Args:
-        password (str, required): password.
-
-        uuid (int or str, [str convert to int], required): unique user
-              identity.
-
-        salt (Any, required): Salt. additional unique identifier
-             (there can be any line: mother's maiden name,
-             favorite writer, etc.).
-
-        key (Any, optional): Additional argument. Defaults to None.
-            If value of 'key' parameter is 'None' then function
-            will generate it.
-
-        hash_password (str, optional): password hash (previously calculated).
+        password (str, required): password
+        uuid (int or str, required): unique user identity number
+        salt (bytes | None, required): additional unique identifier which added
+                                       to the password when generating
+                                       hash_password, there can be any line:
+                                       mother's maiden name, favorite writer,
+                                       etc.
+        key (bytes | None, optional): additional argument, if value is None
+                                      then function will generate it
+                                      automatically
+        hash_password (str, optional): password hash (previously calculated)
 
     """
+
     def __init__(self,
                  password: str,
                  uuid: int | str,
@@ -77,18 +76,34 @@ def __init__(self,
 
     @property
     def get_salt(self) -> bytes:
+        """
+        Getting the value of salt.
+
+        Returns:
+            (bytes): salt
+        """
+
         return self.salt
 
     @property
     def get_key(self) -> bytes:
+        """
+        Getting the value of key.
+
+        Returns:
+            (bytes): key
+        """
+
         return self.key
 
     def password_hash(self) -> str:
-        """Generates a password hash.
+        """
+        Generates a password hash.
 
         Returns:
-            str: Returns hash password.
+            hash password (str): returns blake2b hash
         """
+
         hash_password = blake2b(self.binary_password,
                                 digest_size=self.size_password,
                                 key=self.key,
@@ -96,11 +111,13 @@ def password_hash(self) -> str:
         return hash_password.hexdigest()
 
     def check_password(self) -> bool:
-        """Checks password hash and original password.
+        """
+        Comparison of calculated hash and original password.
 
         Returns:
-            bool: True or False
+            (bool): True or False
         """
+
         if self.hash_password is None:
             return False
         else:
@@ -109,12 +126,14 @@ def check_password(self) -> bool:
                                   verified_hash_password)
 
     def auth_id(self) -> str:
-        """Generates an authenticator ID's for client session
+        """
+        Generates an authenticator token for client session
         connection to server.
 
         Returns:
-            str: Returns auth_id
+            (str): authenticate token
         """
+
         uuid = self.uuid.to_bytes(self.uuid.bit_length(),
                                   byteorder=sys.byteorder)
         result = blake2b(uuid,
diff --git a/mod/logging.py b/mod/logging.py
index 7a54b24f..234848ac 100644
--- a/mod/logging.py
+++ b/mod/logging.py
@@ -18,12 +18,13 @@
     You should have received a copy of the GNU Lesser General Public License
     along with Morelia Server. If not, see <https://www.gnu.org/licenses/>.
 """
+
 import sys
 
 from loguru import logger
 
 from admin import logs
-from mod.config import LOGGING
+from config import LOGGING
 
 
 expiration_date = LOGGING.get('EXPIRATION_DATE')
@@ -31,32 +32,47 @@
 
 
 def add_logging(debug_status: int) -> None:
-    """Enables logging depending on start parameter uvicorn
+    """
+    Enable logging depending on start parameter uvicorn and choice their level.
+    Logging information written in .log file which contains in /log folder and
+    also duplicated in the console.
+
+    Note:
+        application creates two log file contains in /log folder:
+
+        one for error level - `error.log`
+
+        one for debug level - `debug.log`
+
+    Examples:
+        Instead of print we use:
+
+        ``logger.debug('debug message')``
+
+        ``logger.info('info message')``
 
-    Instead of print we use:                       #
-               logger.debug('debug message')       #
-               logger.info('info message')         #
-               logger.warning('warn message')      #
-               logger.error('error message')       #
-               logger.critical('critical message') #
+        ``logger.warning('warn message')``
 
-    The application creates two log/ file:
-               1 - error level
-               2 - debug level
-    The information is also duplicated in the console
+        ``logger.error('error message')``
+
+        ``logger.critical('critical message')``
 
     Args:
-        debug_status (int, requires):
-        50 - CRITICAL;
-        40 - ERROR;
-        30 - WARNING;
-        25 - SUCCESS;
-        20 - INFO;
-        10 - DEBUG;
-        5 - TRACE.
-
-    Returns:
-        None
+        debug_status (int, requires): where number corresponds its level
+
+            `50 - CRITICAL`
+
+            `40 - ERROR`
+
+            `30 - WARNING`
+
+            `25 - SUCCESS`
+
+            `20 - INFO`
+
+            `10 - DEBUG`
+
+            `5 - TRACE`
     """
 
     logger.remove()
diff --git a/mod/protocol/matrix/worker.py b/mod/protocol/matrix/worker.py
index 91c322c8..a2721117 100644
--- a/mod/protocol/matrix/worker.py
+++ b/mod/protocol/matrix/worker.py
@@ -18,12 +18,25 @@
     You should have received a copy of the GNU Lesser General Public License
     along with Morelia Server. If not, see <https://www.gnu.org/licenses/>.
 """
-import json
 
 from mod.db.dbhandler import DBHandler
 
 
 class MatrixProtocol:
+    """
+    Processing requests and forming response according to "Matrix" protocol.
+
+    Read actual description of protocol:
+    https://spec.matrix.org/v1.1/
+
+    Args:
+        request: JSON request from websocket client
+        database (DBHandler): object - database connection point
+
+    Returns:
+        returns class api.Response
+    """
+
     def __init__(self,
                  request,
                  database: DBHandler):
@@ -32,5 +45,13 @@ def __init__(self,
 
     @staticmethod
     def get_response() -> str:
+        """
+        Generates a JSON-object containing result of an instance json
+
+        Returns:
+                (json): json-object which contains validated response
+
+        """
+
         result = "Method not worked"
         return result
diff --git a/mod/protocol/mtp/api.py b/mod/protocol/mtp/api.py
index c99d024b..393c79d4 100644
--- a/mod/protocol/mtp/api.py
+++ b/mod/protocol/mtp/api.py
@@ -27,12 +27,18 @@
 from pydantic import EmailStr
 
 # Version of MoreliaTalk Protocol
-VERSION: str = '1.0'
+VERSION = '1.0'
+REVISION = '17'
 
 # A description of the basic validation scheme for requests and responses.
 
 
 class BaseFlow(BaseModel):
+    """
+    A base class that describes the validation of the Flow object the same for
+    requests and responses.
+    """
+
     time: Optional[int] = None
     type: Optional[str] = None
     title: Optional[str] = None
@@ -44,6 +50,11 @@ class BaseFlow(BaseModel):
 
 
 class BaseUser(BaseModel):
+    """
+    A base class that describes the validation of the User object the same for
+    requests and responses.
+    """
+
     uuid: Optional[str] = None
     login: Optional[str] = None
     username: Optional[str] = None
@@ -52,10 +63,16 @@ class BaseUser(BaseModel):
     password: Optional[str] = None
     is_bot: Optional[bool] = None
     auth_id: Optional[str] = None
+    token_ttl: Optional[int] = None
     email: Optional[EmailStr] = None
 
 
 class BaseMessage(BaseModel):
+    """
+    A base class that describes the validation of the Message object the same
+    for requests and responses.
+    """
+
     uuid: str
     text: Optional[str] = None
     from_user: Optional[str] = None
@@ -71,20 +88,41 @@ class BaseMessage(BaseModel):
 
 
 class BaseData(BaseModel):
+    """
+    A base class that describes the validation of the Data object the same for
+    requests and responses.
+    """
+
     time: Optional[int] = None
     user: Optional[List[BaseUser]] = None
     meta: Optional[Any] = None
 
 
 class BaseErrors(BaseModel):
+    """
+    A base class that describes the validation of the Errors object the same
+    for requests and responses.
+    """
+
     detail: Optional[str] = None
 
 
 class BaseVersion(BaseModel):
+    """
+    A base class that describes the validation of the Jsonapi object the same
+    for requests and responses.
+    """
+
     version: str
+    revision: Optional[str] = None
 
 
 class BaseValidator(BaseModel):
+    """
+    A base class that describes the validation of the main object the same for
+    requests and responses.
+    """
+
     type: str
     jsonapi: BaseVersion
     meta: Optional[Any] = None
@@ -94,47 +132,105 @@ class BaseValidator(BaseModel):
 
 
 class FlowRequest(BaseFlow):
+    """
+    Validation settings for the Flow object
+    """
+
     class Config:
+        """
+        Additional configuration for Request
+        """
+
         title = 'List of flow with UUID is str or None'
     uuid: str = None
 
 
 class UserRequest(BaseUser):
+    """
+    Validation settings for the User object
+    """
+
     class Config:
+        """
+        Additional configuration for Request
+        """
+
         title = 'List of user information'
-    pass
 
 
 class MessageRequest(BaseMessage):
+    """
+    Validation settings for the Message object
+    """
+
     class Config:
+        """
+        Additional configuration for Request
+        """
+
         title = 'List of message information with client_id is int'
+
     client_id: int
 
 
 class DataRequest(BaseData):
+    """
+    Validation settings for the Data object
+    """
+
     class Config:
+        """
+        Additional configuration for Request
+        """
+
         title = 'Main data-object'
+
     flow: Optional[List[FlowRequest]] = None
     message: Optional[List[MessageRequest]] = None
 
 
 class ErrorsRequest(BaseErrors):
+    """
+    Validation settings for the Errors object
+    """
+
     class Config:
+        """
+        Additional configuration for Request
+        """
+
         title = 'Error information'
+
     code: int = None
     status: str = None
     time: int = None
 
 
 class VersionRequest(BaseVersion):
+    """
+    Validation settings for the Jsonapi object
+    """
+
     class Config:
+        """
+        Additional configuration for Request
+        """
+
         title = 'Protocol version'
-    pass
 
 
 class Request(BaseValidator):
+    """
+    Responsible for validation and generation of request in JSON-object.
+    """
+
     class Config:
+        """
+        Additional configuration for Request
+        """
+
         title = 'MoreliaTalk protocol (for request)'
+
     data: Optional[DataRequest] = None
     errors: ErrorsRequest = None
 
@@ -143,47 +239,106 @@ class Config:
 
 
 class FlowResponse(BaseFlow):
+    """
+    Validation settings for the Flow object
+    """
+
     class Config:
+        """
+        Additional configuration for Response
+        """
+
         title = 'List of flow with required UUID and it is str'
+
     uuid: str
 
 
 class UserResponse(BaseUser):
+    """
+    Validation settings for the User object
+    """
+
     class Config:
+        """
+        Additional configuration for Response
+        """
+
         title = 'List of user information'
-    pass
 
 
 class MessageResponse(BaseMessage):
+    """
+    Validation settings for the Message object
+    """
+
     class Config:
+        """
+        Additional configuration for Response
+        """
+
         title = 'List of message information without client_id'
+
     client_id: int = None
 
 
 class DataResponse(BaseData):
+    """
+    Validation settings for the Data object
+    """
+
     class Config:
+        """
+        Additional configuration for Response
+        """
+
         title = 'Main data-object'
+
     flow: Optional[List[FlowResponse]] = None
     message: Optional[List[MessageResponse]] = None
 
 
 class ErrorsResponse(BaseErrors):
+    """
+    Validation settings for the Errors object
+    """
+
     class Config:
+        """
+        Additional configuration for Response
+        """
+
         title = 'Error information. Code, status. time is required'
+
     code: int
     status: str
     time: int
 
 
 class VersionResponse(BaseVersion):
+    """
+    Validation settings for the Jsonapi object
+    """
+
     class Config:
+        """
+        Additional configuration for Response
+        """
+
         title = 'Protocol version'
-    pass
 
 
 class Response(BaseValidator):
+    """
+    Responsible for validation and generation of response in JSON-object.
+    """
+
     class Config:
+        """
+        Additional configuration for Response
+        """
+
         title = 'MoreliaTalk protocol (for response)'
         use_enum_values = False
+
     data: Optional[DataResponse] = None
     errors: ErrorsResponse = None
diff --git a/mod/protocol/mtp/worker.py b/mod/protocol/mtp/worker.py
index 1e4fa8f5..4b3e7151 100644
--- a/mod/protocol/mtp/worker.py
+++ b/mod/protocol/mtp/worker.py
@@ -26,6 +26,7 @@
 
 from pydantic import ValidationError
 from loguru import logger
+from sqlobject.sresults import SelectResults
 
 from mod.protocol.mtp import api
 from mod import error
@@ -34,31 +35,24 @@
 from mod.db.dbhandler import DatabaseWriteError
 from mod.db.dbhandler import DatabaseReadError
 from mod.db.dbhandler import DatabaseAccessError
-from mod.config import SERVER_LIMIT as LIMIT
+from config import SERVER_LIMIT as LIMIT
 
 
 class MTPErrorResponse:
-    """Catcher errors in "try...except" content.
-    Result is class 'api.ErrorsResponse' with information about code,
+    """
+    Catcher errors in "try...except" content.
+
+    Returned 'api.ErrorsResponse' with information about code,
     status, time and detailed description of error that has occurred.
+
     For errors like Exception and other unrecognized errors,
     code "520" and status "Unknown Error" are used.
 
     Args:
         status (str): Error type
         add_info ([Exception] or [str], optional): Additional information
-            to be added. Defaults to None.
-
-    Returns:
-        ErrorResponse.result() returns class 'api.ErrorsResponse'
-        according to protocol, like:
-            {
-                'code': 200,
-                'status': 'Ok',
-                'time': 123456545,
-                'detail': 'successfully'
-                }
-        """
+        to be added. Defaults to None.
+    """
 
     def __init__(self,
                  status: str,
@@ -67,6 +61,16 @@ def __init__(self,
         self.detail = add_info
 
     def result(self) -> api.ErrorsResponse:
+        """
+        Used for returned result which 'api.ErrorsResponse' type.
+
+        Returns:
+            object (api.ErrorResponse): object with information about code,
+            status, time and detailed description of error that has occurred.
+
+            {'code': 200,'status': 'Ok','time': 123456545,'detail': 'successfully'}
+        """
+
         try:
             catch_error = error.check_error_pattern(self.status)
         except Exception as ERROR:
@@ -93,9 +97,13 @@ def result(self) -> api.ErrorsResponse:
 
 
 class MTProtocol:
-    """Processing requests and forming answers according to "MTP" protocol.
-    Protocol version and its actual description:
-    https://github.com/MoreliaTalk/morelia_protocol/blob/master/README.md
+    """
+    Processing requests and forming response according to "MTP" protocol.
+
+    See Also:
+        Read actual description of protocol:
+
+        https://github.com/MoreliaTalk/morelia_protocol/blob/master/README.md
 
     Args:
         request: JSON request from websocket client
@@ -104,10 +112,12 @@ class MTProtocol:
     Returns:
         returns class api.Response
     """
+
     def __init__(self,
                  request,
                  database: DBHandler):
-        self.jsonapi = api.VersionResponse(version=api.VERSION)
+        self.jsonapi = api.VersionResponse(version=api.VERSION,
+                                           revision=api.REVISION)
         self.get_time = int(time())
         self._db = database
 
@@ -158,6 +168,24 @@ def __init__(self,
     def _check_auth(self,
                     uuid: str,
                     auth_id: str) -> namedtuple:
+        """
+        Checking user authentication every each request
+
+        Args:
+            uuid (str): user identification number which granted moreliatalk
+                        server
+            auth_id (str): authentication token which granted moreliatalk
+                            server
+
+        Returns:
+                object (namedtuple): object with two parameters, which contain:
+
+                                     ``result``: True or False
+
+                                     ``error_message``: text description of
+                                     the error
+        """
+
         Result = namedtuple('Result', ['result',
                                        'error_message'])
         try:
@@ -182,9 +210,14 @@ def _check_auth(self,
 
     def get_response(self,
                      response: api.Response = None) -> json:
-        """Generates a JSON-object containing result
-        of an instance of ProtocolMethod class.
         """
+        Generates a JSON-object containing result of an instance json
+
+        Returns:
+            (json): json-object which contains validated response
+
+        """
+
         if response is None:
             result = self.response.json()
             return result
@@ -194,15 +227,17 @@ def get_response(self,
 
     def _check_login(self,
                      login: str) -> bool:
-        """Checks database for a user with the same login
+        """
+        Checks database for a user with the same login and returns True
+        if there is such a user or False if no such user exists.
 
         Args:
             login (str): user login
 
         Returns:
-            True if there is such a user
-            False if no such user exists
+            (bool): True of False
         """
+
         try:
             self._db.get_user_by_login(login)
         except DatabaseReadError:
@@ -214,9 +249,20 @@ def _check_login(self,
 
     def _register_user(self,
                        request: api.Request) -> api.Response:
-        """Registers user who is not in the database.
-        Note: This version also authentication user, that exist in database
         """
+        Registers user who is not in the database.
+
+        See Also:
+            https://github.com/MoreliaTalk/morelia_protocol
+
+        Note:
+            This version also authentication user, that exist in database
+
+        Returns:
+            (api.Response): validated response
+
+        """
+
         uuid = str(uuid4().int)
         password = request.data.user[0].password
         login = request.data.user[0].login
@@ -238,13 +284,15 @@ def _register_user(self,
                               username=username,
                               is_bot=False,
                               auth_id=auth_id,
+                              token_ttl=self.get_time,
                               email=email,
                               avatar=None,
                               bio=None,
                               salt=generated.get_salt,
                               key=generated.get_key)
             user.append(api.UserResponse(uuid=uuid,
-                                         auth_id=auth_id))
+                                         auth_id=auth_id,
+                                         token_ttl=self.get_time))
             data = api.DataResponse(time=self.get_time,
                                     user=user)
             errors = MTPErrorResponse("CREATED")
@@ -257,11 +305,19 @@ def _register_user(self,
 
     def _get_update(self,
                     request: api.Request) -> api.Response:
-        """Provides updates of flows, messages and users in them from time
         """
+        Provides updates of flows, messages and users in them from time.
+
+        See Also:
+            https://github.com/MoreliaTalk/morelia_protocol
+
+        Returns:
+            (api.Response): validated response
+        """
+
         # select all fields of the user table
-        # TODO внести изменения в протокол, добавить фильтр
-        # по дате создания пользователя
+        # TODO внести изменения в протокол:
+        #   добавить фильтр по дате создания пользователя
         message = []
         flow = []
         user = []
@@ -321,8 +377,13 @@ def _get_update(self,
 
     def _send_message(self,
                       request: api.Request) -> api.Response:
-        """Saves user message in database.
         """
+        Saves user message in database.
+
+        See Also:
+            https://github.com/MoreliaTalk/morelia_protocol
+        """
+
         message_uuid = str(uuid4().int)
         flow_uuid = request.data.flow[0].uuid
         text = request.data.message[0].text
@@ -368,9 +429,14 @@ def _send_message(self,
 
     def _all_messages(self,
                       request: api.Request) -> api.Response:
-        """Displays all messages of a specific flow retrieves them
-        from database and issues them as an array consisting of JSON
         """
+        Displays all messages of a specific flow retrieves them
+        from database and issues them as an array consisting of JSON.
+
+        See Also:
+            https://github.com/MoreliaTalk/morelia_protocol
+        """
+
         flow_uuid = request.data.flow[0].uuid
         flow = []
         message = []
@@ -381,15 +447,28 @@ def _all_messages(self,
             message_start = request.data.flow[0].message_start
 
         if request.data.flow[0].message_end is None:
-            message_end = 0
+            message_end = 100
         else:
             message_end = request.data.flow[0].message_end
 
         message_volume = message_end - message_start
 
-        def get_messages(db,
+        def get_messages(db: SelectResults,
                          end: int,
                          start: int = 0) -> list[api.MessageResponse]:
+            """
+            Converts the database object into a list of validated "Message"
+            objects.
+
+            Args:
+                db (SelectResults): database query result
+                end (int): last message number
+                start (int): first message number
+
+            Returns:
+                (list[api.MessageResponse]): list contains of validated object
+            """
+
             _list = []
             for element in db[start:end]:
                 _list.append(api.MessageResponse(
@@ -418,9 +497,7 @@ def get_messages(db,
                                       str(flow_error))
         else:
             if MESSAGE_COUNT <= LIMIT.getint("messages"):
-                flow.append(api.FlowResponse(uuid=flow_uuid,
-                                             message_start=message_start,
-                                             message_end=message_end))
+                flow.append(api.FlowResponse(uuid=flow_uuid))
                 message = get_messages(dbquery,
                                        LIMIT.getint("messages"))
                 errors = MTPErrorResponse("OK")
@@ -452,8 +529,13 @@ def get_messages(db,
 
     def _add_flow(self,
                   request: api.Request) -> api.Response:
-        """Allows to add a new flow to database
         """
+        Allows to add a new flow to database.
+
+        See Also:
+            https://github.com/MoreliaTalk/morelia_protocol
+        """
+
         flow_uuid = str(uuid4().int)
         owner = request.data.flow[0].owner
         users = request.data.flow[0].users
@@ -501,9 +583,14 @@ def _add_flow(self,
 
     def _all_flow(self,
                   request: api.Request) -> api.Response:
-        """Allows to get a list of all flows and information about them
-        from database
         """
+        Allows to get a list of all flows and information about them
+        from database.
+
+        See Also:
+            https://github.com/MoreliaTalk/morelia_protocol
+        """
+
         flow = []
         dbquery = self._db.get_all_flow()
 
@@ -532,8 +619,13 @@ def _all_flow(self,
 
     def _user_info(self,
                    request: api.Request) -> api.Response:
-        """Provides information about all personal settings of user.
         """
+        Provides information about all personal settings of user.
+
+        See Also:
+            https://github.com/MoreliaTalk/morelia_protocol
+        """
+
         users_volume = len(request.data.user)
         user = []
 
@@ -555,7 +647,7 @@ def _user_info(self,
                                                  is_bot=dbquery.is_bot))
             logger.success("\'_user_info\' executed successfully")
         else:
-            errors = MTPErrorResponse("FORBIDDEN",
+            errors = MTPErrorResponse("TOO_MANY_REQUESTS",
                                       f"Requested more {LIMIT.get('users')}"
                                       " users than server limit")
 
@@ -569,11 +661,16 @@ def _user_info(self,
 
     def _authentication(self,
                         request: api.Request) -> api.Response:
-        """Performs authentication of registered client,
+        """
+        Performs authentication of registered client,
         with issuance of a unique hash number of connection session.
         During authentication password transmitted by client
         and password contained in server database are verified.
+
+        See Also:
+            https://github.com/MoreliaTalk/morelia_protocol
         """
+
         login = request.data.user[0].login
         password = request.data.user[0].password
         user = []
@@ -610,8 +707,13 @@ def _authentication(self,
 
     def _delete_user(self,
                      request: api.Request) -> api.Response:
-        """Function irretrievably deletes the user from database.
         """
+        Function irretrievably deletes the user from database.
+
+        See Also:
+            https://github.com/MoreliaTalk/morelia_protocol
+        """
+
         uuid = str(uuid4().int)
         login = request.data.user[0].login
         password = request.data.user[0].password
@@ -644,9 +746,14 @@ def _delete_user(self,
 
     def _delete_message(self,
                         request: api.Request) -> api.Response:
-        """Function deletes the message from database Message
+        """
+        Function deletes the message from database Message
         table by its ID.
+
+        See Also:
+            https://github.com/MoreliaTalk/morelia_protocol
         """
+
         message_uuid = request.data.message[0].uuid
 
         try:
@@ -674,9 +781,14 @@ def _delete_message(self,
 
     def _edited_message(self,
                         request: api.Request) -> api.Response:
-        """Changes text and time in database Message table.
+        """
+        Changes text and time in database Message table.
         Value of edited_status column changes from None to True.
+
+        See Also:
+            https://github.com/MoreliaTalk/morelia_protocol
         """
+
         message_uuid = request.data.message[0].uuid
 
         try:
@@ -699,9 +811,14 @@ def _edited_message(self,
 
     def _ping_pong(self,
                    request: api.Request) -> api.Response:
-        """Generates a response to a client's request
+        """
+        Generates a response to a client's request
         for communication between server and client.
+
+        See Also:
+            https://github.com/MoreliaTalk/morelia_protocol
         """
+
         errors = MTPErrorResponse("OK")
         logger.success("\'_ping_pong\' executed successfully")
 
@@ -714,10 +831,15 @@ def _errors(self,
                 status: str = None,
                 add_info: Exception | str = None,
                 request: api.Request = None) -> api.Response:
-        """Handles cases when a request to server is not recognized by it.
+        """
+        Handles cases when a request to server is not recognized by it.
         Get a standard answer type: error, which contains an object
         with a description of error.
+
+        See Also:
+            https://github.com/MoreliaTalk/morelia_protocol
         """
+
         if request is not None:
             response = request.type
         else:
diff --git a/server.py b/server.py
index a2c548b3..30db4129 100644
--- a/server.py
+++ b/server.py
@@ -41,9 +41,9 @@
 from mod.controller import MainHandler
 from mod.db.dbhandler import DBHandler
 from admin import admin
-from mod.config import LOGGING
-from mod.config import TEMPLATES as DIRECTORY
-from mod.config import DATABASE
+from config import LOGGING
+from config import TEMPLATES as DIRECTORY
+from config import DATABASE
 # ************** Morelia module end ******************
 
 
@@ -92,12 +92,48 @@
 
 @app.get('/')
 def home_page(request: Request):
+    """
+    Rendered home page where presents information about current working server
+
+    Args:
+        request(Request): not used
+
+    Returns:
+        (text/html): rendered text to html
+
+    """
+
     return HTMLResponse("<h1>MoreliaTalkServer</h1>")
 
 
 # Chat websocket
 @app.websocket("/ws")
 async def websocket_endpoint(websocket: WebSocket):
+    """
+    Responsible for establishing a websocket connection between server and
+    client and exchanging requests/responses.
+
+    Notes:
+        Waiting for client to connect via websockets, after which receive a
+        request from client as a JSON-object create request object and pass
+        to class MainHandler.
+
+        After MTProtocol or MatrixProtocol processing request, "get_response"
+        method generates response in JSON-object format.
+
+        After disconnecting the client (by decision of client or error)
+        must interrupt cycle otherwise the next clients will not be able
+        to connect.
+
+        `code = 1000` - normal session termination
+
+    Args:
+        websocket(WebSocket):
+
+    Returns:
+        websocket(WebSocket):
+    """
+
     # Waiting for the client to connect via websockets
     await websocket.accept()
     logger.info("".join(("Clients information: ",
diff --git a/setup.cfg b/setup.cfg
index 3f15ac95..819bcf3e 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -2,5 +2,8 @@
 branch = True
 omit = *tests*
 
+[coverage:report]
+precision = 0
+
 [flake8]
 max-line-length = 79
diff --git a/tests/fixtures/valid.json b/tests/fixtures/valid.json
index f0599dba..0bbc1fdd 100644
--- a/tests/fixtures/valid.json
+++ b/tests/fixtures/valid.json
@@ -53,6 +53,7 @@
             "username": "Vasya",
             "is_bot": true,
             "auth_id": "4646hjgjhg64",
+            "token_ttl": 123456123456,
             "email": "querty@querty.com",
             "avatar": "fffdddddd",
             "bio": "My bio"
@@ -66,7 +67,8 @@
         "detail": "successfully"
         },
     "jsonapi": {
-        "version": "1.0"
+        "version": "1.0",
+        "revision": "17"
         },
     "meta": null
     }
\ No newline at end of file
diff --git a/tests/fixtures/wrong.json b/tests/fixtures/wrong.json
index 6a85cfd9..9707afb6 100644
--- a/tests/fixtures/wrong.json
+++ b/tests/fixtures/wrong.json
@@ -65,7 +65,8 @@
         "detail": "successfully"
         },
     "jsonapi": {
-        "version": "1.0"
+        "version": "1.0",
+        "revision": "17"
         },
     "meta": null
     }
\ No newline at end of file
diff --git a/tests/test_dbhandler.py b/tests/test_dbhandler.py
index 53f32bea..5a87c224 100644
--- a/tests/test_dbhandler.py
+++ b/tests/test_dbhandler.py
@@ -99,7 +99,7 @@ def test_str(self):
 
     def test_repr(self):
         self.assertEqual(repr(self.db),
-                         "class DBHandler: debug=0 logger=None loglevel=None")
+                         "Class DBHandler: debug=0 logger=None loglevel=None")
 
 
 class TestDBHandlerMethods(unittest.TestCase):
diff --git a/tests/test_protocol_mtp_api.py b/tests/test_protocol_mtp_api.py
index 8280bee2..6d7ee8f0 100644
--- a/tests/test_protocol_mtp_api.py
+++ b/tests/test_protocol_mtp_api.py
@@ -54,7 +54,14 @@ def tearDown(self):
         del self.valid
 
     def test_validation_valid_json(self):
-        self.assertIsInstance(self.valid.dict(), dict)
+        result = self.valid.dict()
+        self.assertIsInstance(result, dict)
+        self.assertEqual(result['data']['user'][0]['token_ttl'],
+                         123456123456)
+        self.assertEqual(result['data']['message'][0]['client_id'],
+                         123456)
+        self.assertEqual(result['jsonapi']['version'], '1.0')
+        self.assertEqual(result['jsonapi']['revision'], '17')
 
     def test_validation_wrong_json(self):
         try:
@@ -65,8 +72,8 @@ def test_validation_wrong_json(self):
     def test_api_request(self):
         try:
             api.Request.parse_file(WRONG_REQUEST)
-        except Exception as ERROR:
-            result = ERROR.errors()
+        except Exception as err:
+            result = err.errors()
             self.assertEqual(result[0].get("msg"),
                              "str type expected")
             self.assertEqual(result[1].get("msg"),
@@ -85,8 +92,8 @@ def test_api_request(self):
     def test_api_response(self):
         try:
             api.Response.parse_file(WRONG_RESPONSE)
-        except Exception as ERROR:
-            result = ERROR.errors()
+        except Exception as err:
+            result = err.errors()
             self.assertEqual(result[0].get("msg"),
                              "field required")
             self.assertEqual(result[1].get("msg"),
@@ -103,20 +110,8 @@ def test_api_response(self):
     def test_api_wrong_data_and_errors_in_request(self):
         try:
             api.Request.parse_file(WRONG_DATA_ERRORS)
-        except Exception as ERROR:
-            result = ERROR.errors()
-            self.assertEqual(result[0].get("msg"),
-                             "value is not a valid dict")
-            self.assertEqual(result[1].get("msg"),
-                             "value is not a valid dict")
-        else:
-            self.assertIsNone(self.test)
-
-    def test_api_wrong_data_and_errors_in_response(self):
-        try:
-            api.Response.parse_file(WRONG_DATA_ERRORS)
-        except Exception as ERROR:
-            result = ERROR.errors()
+        except Exception as err:
+            result = err.errors()
             self.assertEqual(result[0].get("msg"),
                              "value is not a valid dict")
             self.assertEqual(result[1].get("msg"),
@@ -127,20 +122,8 @@ def test_api_wrong_data_and_errors_in_response(self):
     def test_api_wrong_flow_and_message_in_request(self):
         try:
             api.Request.parse_file(WRONG_FLOW_MESSAGE)
-        except Exception as ERROR:
-            result = ERROR.errors()
-            self.assertEqual(result[0].get("msg"),
-                             "value is not a valid list")
-            self.assertEqual(result[1].get("msg"),
-                             "value is not a valid list")
-        else:
-            self.assertIsNone(self.test)
-
-    def test_api_wrong_flow_and_message_in_response(self):
-        try:
-            api.Response.parse_file(WRONG_FLOW_MESSAGE)
-        except Exception as ERROR:
-            result = ERROR.errors()
+        except Exception as err:
+            result = err.errors()
             self.assertEqual(result[0].get("msg"),
                              "value is not a valid list")
             self.assertEqual(result[1].get("msg"),
diff --git a/tests/test_protocol_mtp_worker.py b/tests/test_protocol_mtp_worker.py
index 3c30d2a8..309833d8 100644
--- a/tests/test_protocol_mtp_worker.py
+++ b/tests/test_protocol_mtp_worker.py
@@ -31,7 +31,7 @@
 from mod.db.dbhandler import DBHandler
 from mod.protocol.mtp.worker import MTProtocol
 from mod.protocol.mtp.worker import MTPErrorResponse
-from mod.config import SERVER_LIMIT as LIMIT
+from config import SERVER_LIMIT as LIMIT
 
 # Add path to directory with code being checked
 # to variable 'PATH' to import modules from directory
@@ -55,12 +55,14 @@
 NON_VALID_ERRORS = os.path.join(FIXTURES_PATH, "non_valid_errors.json")
 ERRORS_ONLY_TYPE = os.path.join(FIXTURES_PATH, "errors_only_type.json")
 
+DATABASE = "sqlite:/:memory:?debug=1"
+
 
 class TestCheckAuthToken(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         self.db.create_table()
@@ -90,7 +92,7 @@ def test_check_wrong_uuid(self):
                                             'auth_id')
         self.assertFalse(check_auth.result)
         self.assertEqual(check_auth.error_message,
-                         "User wasn't found in the database")
+                         "User was not authenticated")
 
     def test_check_wrong_auth_id(self):
         run_method = MTProtocol('test',
@@ -106,7 +108,7 @@ class TestCheckLogin(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         self.db.create_table()
@@ -137,7 +139,7 @@ class TestRegisterUser(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         self.db.create_table()
@@ -170,6 +172,14 @@ def test_user_write_in_database(self):
         dbquery = self.db.get_user_by_login(login="login")
         self.assertEqual(dbquery.login, "login")
 
+    def test_token_ttl_write_to_database(self):
+        run_method = MTProtocol(self.test,
+                                self.db)
+        result = json.loads(run_method.get_response())
+        dbquery = self.db.get_user_by_login(login="login")
+        self.assertEqual(dbquery.token_ttl,
+                         result['data']['user'][0]['token_ttl'])
+
     def test_uuid_write_in_database(self):
         run_method = MTProtocol(self.test,
                                 self.db)
@@ -203,7 +213,7 @@ class TestGetUpdate(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         self.db.create_table()
@@ -281,6 +291,13 @@ def test_check_message_in_result(self):
         self.assertEqual(result["data"]["message"][1]["uuid"],
                          "112")
 
+    def test_check_client_id_in_result(self):
+        run_method = MTProtocol(self.test,
+                                self.db)
+        result = json.loads(run_method.get_response())
+        self.assertEqual(result["data"]["message"][1]["client_id"],
+                         None)
+
     def test_check_flow_in_result(self):
         run_method = MTProtocol(self.test,
                                 self.db)
@@ -309,7 +326,7 @@ class TestSendMessage(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         self.db.create_table()
@@ -376,7 +393,7 @@ class TestAllMessages(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         self.db.create_table()
@@ -451,6 +468,8 @@ def test_all_message_less_limit(self):
         result = json.loads(run_method.get_response())
         self.assertEqual(result["errors"]["status"],
                          "OK")
+        self.assertEqual(result["data"]["flow"][0]["message_start"], None)
+        self.assertEqual(result["data"]["flow"][0]["message_end"], None)
 
     def test_message_end_in_response(self):
         run_method = MTProtocol(self.test,
@@ -465,10 +484,13 @@ def test_message_start_in_response(self):
         self.assertEqual(result["data"]["flow"][0]["message_start"], 0)
 
     def test_check_message_in_database(self):
-        MTProtocol(self.test,
-                   self.db)
+        run_method = MTProtocol(self.test,
+                                self.db)
+        result = json.loads(run_method.get_response())
         dbquery = self.db.get_message_by_exact_time(666)
         self.assertEqual(dbquery[0].text, "Privet")
+        self.assertEqual(result['data']['message'][0]['client_id'],
+                         None)
 
     def test_wrong_message_volume(self):
         self.test.data.flow[0].message_end = 256
@@ -491,7 +513,7 @@ class TestAddFlow(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         self.db.create_table()
@@ -561,7 +583,7 @@ class TestAllFlow(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         self.db.create_table()
@@ -600,7 +622,7 @@ class TestUserInfo(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         self.db.create_table()
@@ -640,14 +662,14 @@ def test_check_many_user_info(self):
                                 self.db)
         result = json.loads(run_method.get_response())
         self.assertEqual(result["errors"]["status"],
-                         "Forbidden")
+                         "Too Many Requests")
 
 
 class TestAuthentication(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         gen_hash = lib.Hash("password", 123456,
@@ -705,7 +727,7 @@ class TestDeleteUser(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         self.db.create_table()
@@ -725,6 +747,9 @@ def test_delete_user(self):
         result = json.loads(run_method.get_response())
         self.assertEqual(result["errors"]["status"],
                          "OK")
+        check_db = self.db.get_user_by_login(login='User deleted')
+        self.assertEqual(check_db.key, b'deleted')
+        self.assertEqual(check_db.salt, b'deleted')
 
     def test_wrong_login(self):
         self.test.data.user[0].login = "wrong_login"
@@ -747,7 +772,7 @@ class TestDeleteMessage(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         self.db.create_table()
@@ -805,7 +830,7 @@ class TestEditedMessage(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         self.db.create_table()
@@ -856,7 +881,7 @@ class TestPingPong(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         self.db.create_table()
@@ -882,7 +907,7 @@ class TestErrors(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         logger.remove()
-        cls.db = DBHandler(uri="sqlite:/:memory:")
+        cls.db = DBHandler(uri=DATABASE)
 
     def setUp(self):
         self.db.create_table()
@@ -935,5 +960,30 @@ def test_correct_status_in_catching_error(self):
         self.assertIsInstance(result.detail, str)
 
 
+class TestJsonapi(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        logger.remove()
+        cls.db = DBHandler(uri=DATABASE)
+
+    def setUp(self):
+        self.db.create_table()
+        self.db.add_user(uuid="123456",
+                         login="login",
+                         password="password",
+                         auth_id="auth_id")
+        self.test = api.Request.parse_file(PING_PONG)
+
+    def tearDown(self):
+        self.db.delete_table()
+
+    def test_api_version_and_revision(self):
+        run_method = MTProtocol(self.test,
+                                self.db)
+        result = json.loads(run_method.get_response())
+        self.assertEqual(result['jsonapi']['version'], api.VERSION)
+        self.assertEqual(result['jsonapi']['revision'], api.REVISION)
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/test_server.py b/tests/test_server.py
new file mode 100644
index 00000000..425d3fe1
--- /dev/null
+++ b/tests/test_server.py
@@ -0,0 +1,67 @@
+import json
+
+from starlette.testclient import TestClient, WebSocketTestSession
+from starlette.websockets import WebSocketDisconnect
+
+import unittest
+
+from loguru import logger
+logger.disable("")
+
+from server import app
+
+
+class TestWebsocket(unittest.TestCase):
+    class DisconnectErr(Exception):
+        pass
+
+    @classmethod
+    def setUpClass(cls):
+        cls.ws_client = TestClient(app)
+
+    def test_normal_connect(self):
+        with self.ws_client.websocket_connect("/ws") as connection:
+            self.assertIsInstance(connection, WebSocketTestSession)
+
+    def test_not_websocket_endpoint_connect(self):
+        with self.assertRaises(WebSocketDisconnect):
+            with self.ws_client.websocket_connect("/no-ws"):
+                pass
+
+    def test_normal_disconnect(self):
+        with self.ws_client.websocket_connect("/ws") as connection:
+            connection.close()
+
+    def test_not_normal_disconnect(self):
+        with self.assertRaises(self.DisconnectErr):
+            with self.ws_client.websocket_connect("/ws") as connection:
+                def callback():
+                    raise self.DisconnectErr
+
+                connection.exit_stack.callback(callback)
+                connection.close(1006)
+
+    def test_send_normal_message(self):
+        with self.ws_client.websocket_connect("/ws") as connection:
+            connection.send_json({"type": "ping-pong",
+                                  "data": {"user": [{}]},
+                                  "jsonapi": {"version": "1.0",
+                                              "revision": "17"},
+                                  "meta": None})
+            self.assertIsNotNone(json.loads(connection.receive_bytes()))
+
+    def test_send_incorrect_message(self):
+        with self.assertRaises(WebSocketDisconnect):
+            with self.ws_client.websocket_connect("/ws") as connection:
+                connection.send_text("hello error!")
+                connection.receive_bytes()
+
+
+class TestMainPage(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.test_client = TestClient(app)
+
+    def test_main_page(self):
+        response = self.test_client.get("/")
+        self.assertEqual(response.text, "<h1>MoreliaTalkServer</h1>")