diff --git a/back/add_poems_and_filters.py b/back/add_poems_and_filters.py
index ad6d980..c29d6c3 100644
--- a/back/add_poems_and_filters.py
+++ b/back/add_poems_and_filters.py
@@ -2,6 +2,7 @@ from sqlalchemy.orm import Session
 from sqlalchemy.ext.asyncio import AsyncSession
 from typing import Annotated
 from fastapi import Depends
+from sqlalchemy import select
 from . import auth_utils, orm_models, pydantic_schemas
 import datetime
 
@@ -45,10 +46,9 @@ async def add_poems_to_db(async_db: AsyncSession):
     # close the file
     f1.close()
 
-
 async def filter_ann(schema: pydantic_schemas.SortAnnouncements, db: Annotated[Session, Depends(auth_utils.get_session)]):
     """Функция для последовательного применения различных фильтров (через схему SortAnnouncements)"""
-    res = db.query(orm_models.Announcement)
+    res = await db.execute(select(orm_models.Announcement)).scalars().all()
     fields = schema.__dict__ # параметры передоваемой схемы SortAnnouncements (ключи и значения)
     # проходим по названиям фильтров и их значениям
     for name, filt in fields.items():
@@ -56,17 +56,17 @@ async def filter_ann(schema: pydantic_schemas.SortAnnouncements, db: Annotated[S
         if filt is not None:
             d = {name: filt}
             # фильтруем
-            res = res.filter_by(**d)
+            res = await res.filter_by(**d)
     # возвращаем все подходящие объявления
-    return res.all()
+    await res.all()
 
 
-def check_obsolete(db: Annotated[Session, Depends(auth_utils.get_session)], current_date: datetime.date):
+async def check_obsolete(db: Annotated[Session, Depends(auth_utils.get_session)], current_date: datetime.date):
     """
     Функция участвует в процессе обновления поля obsolete у всех объявлений раз в сутки
     """
     # обращаемся ко всем объявлениям бд
-    announcements = db.query(orm_models.Announcement).all()
+    announcements = await db.execute(select(orm_models.Announcement)).scalars().all()
     # для каждого объявления
     for ann in announcements:
         # если просрочено
diff --git a/back/api.py b/back/api.py
index 44bebba..e3440e8 100644
--- a/back/api.py
+++ b/back/api.py
@@ -10,6 +10,7 @@ from fastapi.requests import Request
 from typing import Any, Annotated, List, Union
 from starlette.staticfiles import StaticFiles
 from sqlalchemy.orm import Session
+from sqlalchemy import select
 
 import requests
 from uuid import uuid4
@@ -48,9 +49,9 @@ async def announcements_list(db: Annotated[Session, Depends(auth_utils.get_sessi
     # параметры для сортировки (схема pydantic schemas.SortAnnouncements)
     params_to_sort = pydantic_schemas.SortAnnouncements(obsolete=obsolete, user_id=user_id, metro=metro, category=category)
     # получаем результат
-    result = add_poems_and_filters.filter_ann(db=db, schema=params_to_sort)
+    result = await add_poems_and_filters.filter_ann(db=db, schema=params_to_sort)
 
-    return result
+    await result
 
 
 # получаем данные одного объявления
@@ -60,9 +61,10 @@ async def single_announcement(ann_id:int, db: Annotated[Session, Depends(auth_ut
 # В последствии будем вставлять данные в html-форму
     try:
         announcement = db.get(orm_models.Announcement, ann_id)
-        return announcement
+        #announcement = await db.execute(select(orm_models.Announcement)).scalars().all()
+        await announcement
     except:
-        return {"Answer" : False} #если неуданый доступ, то сообщаем об этом
+        await {"Answer" : False} #если неуданый доступ, то сообщаем об этом
 
 
 # Занести объявление в базу данных
@@ -95,9 +97,9 @@ async def put_in_db(name: Annotated[str, Form()], category: Annotated[str, Form(
         db.add(temp_ancmt)     # добавляем в бд
         db.commit()     # сохраняем изменения
         db.refresh(temp_ancmt)  # обновляем состояние объекта
-        return {"Answer" : True}
+        await {"Answer" : True}
     except:
-        return {"Answer" : False}
+        await {"Answer" : False}
 
 
 # Удалить объявления из базы
@@ -105,12 +107,13 @@ async def put_in_db(name: Annotated[str, Form()], category: Annotated[str, Form(
 async def delete_from_db(announcement: pydantic_schemas.DelAnnouncement, db: Annotated[Session, Depends(auth_utils.get_session)]):    # функция удаления объекта из БД
     try:
         # находим объект с заданным id в бд
-        to_delete = db.query(orm_models.Announcement).filter(orm_models.Announcement.id==announcement.id).first()
+        #to_delete = db.query(orm_models.Announcement).filter(orm_models.Announcement.id==announcement.id).first()
+        to_delete = await db.execute(select(orm_models.Announcement)).scalars().filter(orm_models.Announcement.id==announcement.id).first()
         db.delete(to_delete)   # удаление из БД
         db.commit()     # сохраняем изменения
-        return {"Answer" : True}
+        await {"Answer" : True}
     except:
-        return {"Answer" : False}
+        await {"Answer" : False}
     
 
 # Забронировать объявление
@@ -118,7 +121,8 @@ async def delete_from_db(announcement: pydantic_schemas.DelAnnouncement, db: Ann
 async def change_book_status(data: pydantic_schemas.Book, current_user: Annotated[pydantic_schemas.User, Depends(auth_utils.get_current_user)], 
         db: Annotated[Session, Depends(auth_utils.get_session)]):
     # Находим объявление по данному id
-    announcement_to_change = db.query(orm_models.Announcement).filter(orm_models.Announcement.id == data.id).first()
+    #announcement_to_change = db.query(orm_models.Announcement).filter(orm_models.Announcement.id == data.id).first()
+    announcement_to_change = await db.execute(select(orm_models.Announcement).where(orm_models.Announcement.id == data.id)).scalars().first()
     # Проверяем, что объявление с данным id существует
     if not announcement_to_change:
         raise HTTPException(status_code=404, detail="Item not found")
@@ -131,7 +135,7 @@ async def change_book_status(data: pydantic_schemas.Book, current_user: Annotate
         # фиксируем изменения в бд
         db.commit()
         db.refresh(announcement_to_change)
-        return {"Success": True}   
+        await {"Success": True}   
 
 
 # reginstration
@@ -140,7 +144,8 @@ async def create_user(nickname: Annotated[str, Form()], password: Annotated[str,
         name: Annotated[str, Form()]=None, surname: Annotated[str, Form()]=None, avatar: Annotated[UploadFile, Form()]=None):
 
     # проверяем, что юзера с введенным никнеймом не существует в бд
-    if db.query(orm_models.User).filter(orm_models.User.nickname == nickname).first() == None:
+    #if db.query(orm_models.User).filter(orm_models.User.nickname == nickname).first() == None:
+    if await db.execute(select(orm_models.User).where(orm_models.User.nickname == nickname)).scalars().first() == None:
         # создаем нового юзера
         new_user = orm_models.User(nickname=nickname, hashed_password=auth_utils.get_password_hash(password),
         name=name, surname=surname, reg_date=datetime.date.today())
@@ -148,8 +153,8 @@ async def create_user(nickname: Annotated[str, Form()], password: Annotated[str,
         db.add(new_user)
         db.commit()
         db.refresh(new_user)  # обновляем состояние объекта
-        return {"Success": True}
-    return {"Success": False, "Message": "Пользователь с таким email уже зарегестрирован"}
+        await {"Success": True}
+    await {"Success": False, "Message": "Пользователь с таким email уже зарегестрирован"}
 
 
 # функция для генерации токена после успешного входа пользователя
@@ -172,13 +177,13 @@ async def login_for_access_token(
     access_token = auth_utils.create_access_token(
         data={"user_id": user.id}, expires_delta=access_token_expires
     )
-    return {"access_token":access_token}
+    await {"access_token":access_token}
 
 
 # получаем данные успешно вошедшего пользователя
 @app.get("/api/users/me", response_model=pydantic_schemas.User) #
 async def read_users_me(current_user: Annotated[pydantic_schemas.User, Depends(auth_utils.get_current_active_user)]):
-    return current_user
+    await current_user
 
 
 # изменяем рейтинг пользователя
@@ -193,7 +198,7 @@ async def add_points(data: pydantic_schemas.AddRating, current_user: Annotated[p
         user.num_of_ratings += 1
         db.commit()
         db.refresh(user)  # обновляем состояние объекта
-        return {"Success": True}
+        await {"Success": True}
 
 
 # получаем рейтинг пользователя
@@ -202,22 +207,25 @@ async def add_points(user_id: int, db: Annotated[Session, Depends(auth_utils.get
     user = auth_utils.get_user_by_id(db, user_id=user_id)
     if not user:
         raise HTTPException(status_code=404, detail="Item not found")
-    return {"rating": user.rating}
+    await {"rating": user.rating}
 
 
 # Отправляем стихи
 @app.get("/api/user/poem", response_model=pydantic_schemas.Poem)
 async def poems_to_front(db: Annotated[Session, Depends(auth_utils.get_session)]): 
-    num_of_poems = db.query(orm_models.Poems).count()  # определяем кол-во стихов в бд
+    #num_of_poems = db.query(orm_models.Poems).count()  # определяем кол-во стихов в бд
+    num_of_poems = await db.execute(select(orm_models.Poems)).scalars().count() # определяем кол-во стихов в бд
     # если стихов в бд нет
     if num_of_poems < 1:
         add_poems_and_filters.add_poems_to_db(db) # добавляем поэмы в базу данных
-        num_of_poems = db.query(orm_models.Poems).count()  # определяем кол-во стихов в бд
+        num_of_poems = await db.execute(select(orm_models.Poems)).scalars().count() # определяем кол-во стихов в бд
+        #num_of_poems = db.query(orm_models.Poems).count()  # определяем кол-во стихов в бд
     rand_id = random.randint(1, num_of_poems)  # генерируем номер стихотворения
-    poem = db.query(orm_models.Poems).filter(orm_models.Poems.id == rand_id).first() # находим стих в бд
+    #poem = db.query(orm_models.Poems).filter(orm_models.Poems.id == rand_id).first() # находим стих в бд
+    poem = await db.execute(select(orm_models.Poems).where(orm_models.Poems.id == rand_id)).scalars().first() # находим стих в бд
     if not poem:
         raise HTTPException(status_code=404, detail="Poem not found")
-    return poem
+    await poem
 
 
 @app.get("/api/trashbox", response_model=List[pydantic_schemas.TrashboxResponse])
@@ -271,12 +279,12 @@ async def get_trashboxes(data: pydantic_schemas.TrashboxRequest = Depends()):#к
                 if a in temp_dict["Categories"] and temp_dict not in trashboxes:
                     trashboxes.append(temp_dict)
     uniq_trashboxes = [pydantic_schemas.TrashboxResponse(**ast.literal_eval(el1)) for el1 in set([str(el2) for el2 in trashboxes])]
-    return uniq_trashboxes
+    await uniq_trashboxes
 
 
 @app.get("/{rest_of_path:path}")
 async def react_app(req: Request, rest_of_path: str):
-    return templates.TemplateResponse('index.html', { 'request': req })
+    await templates.TemplateResponse('index.html', { 'request': req })
 
 
 @app.post("/api/announcement/dispose")
@@ -295,12 +303,13 @@ async def dispose(data: pydantic_schemas.DisposeRequest, current_user_schema: An
     db.add(new_trashox)
     # в соответствии с логикой api, после утилизации объявление пользователя удаляется
     # находим объявление с айди data.ann_id
-    ann_to_del = db.query(orm_models.Announcement).filter(orm_models.Announcement.id == data.ann_id).first() # находим стих в бд
+    #ann_to_del = db.query(orm_models.Announcement).filter(orm_models.Announcement.id == data.ann_id).first() # находим стих в бд
+    ann_to_del = await db.execute(select(orm_models.Announcement).where(orm_models.Announcement.id == data.ann_id)).scalars().first() # находим стих в бд
     if not ann_to_del:
         raise HTTPException(status_code=404, detail="Announcement not found")
     # удаляем объявление из бд
     db.delete(ann_to_del)
     db.commit()
     db.refresh(new_trashox)  # обновляем состояние объекта
-    return {"Success": True}
+    await {"Success": True}
     
diff --git a/back/db.py b/back/db.py
index a2a3b41..5840936 100644
--- a/back/db.py
+++ b/back/db.py
@@ -4,8 +4,7 @@ from sqlalchemy.orm import sessionmaker
 from sqlalchemy.ext.declarative import declarative_base
 
 
-SQLALCHEMY_DATABASE_URL = 'postgresql+asyncpg://postgres:D560c34V112Ak@localhost/porridger'
-
+SQLALCHEMY_DATABASE_URL = "sqlite+aiosqlite:///./sql_app.db"
 engine = create_async_engine(SQLALCHEMY_DATABASE_URL, echo=True)
 
 SessionLocal = sessionmaker(bind=engine, class_=AsyncSession, expire_on_commit=False)