diff --git a/channels/vk/build.gradle.kts b/channels/vk/build.gradle.kts
new file mode 100644
index 00000000..7c0b19e6
--- /dev/null
+++ b/channels/vk/build.gradle.kts
@@ -0,0 +1,20 @@
+import plugins.publish.POM_DESCRIPTION
+import plugins.publish.POM_NAME
+
+ext[POM_NAME] = "JAICF-Kotlin VK Channel"
+ext[POM_DESCRIPTION] = "JAICF-Kotlin Vkontakte Channel implementation. Enables JAICF-Kotlin integration with vk.com"
+
+plugins {
+    `jaicf-kotlin`
+    `jaicf-publish`
+    `jaicf-junit`
+}
+
+val vkSdk = "1.0.10-SNAPSHOT"
+val log4jAdapter = "2.14.1"
+
+dependencies {
+    core()
+    api("com.vk.api:sdk:$vkSdk")
+    api("org.apache.logging.log4j:log4j-to-slf4j:$log4jAdapter")
+}
diff --git a/channels/vk/src/main/java/com/vk/api/sdk/client/VkApiClient.java b/channels/vk/src/main/java/com/vk/api/sdk/client/VkApiClient.java
new file mode 100644
index 00000000..97988cc2
--- /dev/null
+++ b/channels/vk/src/main/java/com/vk/api/sdk/client/VkApiClient.java
@@ -0,0 +1,281 @@
+package com.vk.api.sdk.client;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.vk.api.sdk.actions.Account;
+import com.vk.api.sdk.actions.Ads;
+import com.vk.api.sdk.actions.AppWidgets;
+import com.vk.api.sdk.actions.Apps;
+import com.vk.api.sdk.actions.Auth;
+import com.vk.api.sdk.actions.Board;
+import com.vk.api.sdk.actions.Database;
+import com.vk.api.sdk.actions.Docs;
+import com.vk.api.sdk.actions.Execute;
+import com.vk.api.sdk.actions.Fave;
+import com.vk.api.sdk.actions.Friends;
+import com.vk.api.sdk.actions.Gifts;
+import com.vk.api.sdk.actions.Groups;
+import com.vk.api.sdk.actions.GroupsLongPoll;
+import com.vk.api.sdk.actions.Likes;
+import com.vk.api.sdk.actions.LongPoll;
+import com.vk.api.sdk.actions.Market;
+import com.vk.api.sdk.actions.Messages;
+import com.vk.api.sdk.actions.Newsfeed;
+import com.vk.api.sdk.actions.Notes;
+import com.vk.api.sdk.actions.Notifications;
+import com.vk.api.sdk.actions.OAuth;
+import com.vk.api.sdk.actions.Orders;
+import com.vk.api.sdk.actions.Pages;
+import com.vk.api.sdk.actions.Photos;
+import com.vk.api.sdk.actions.Polls;
+import com.vk.api.sdk.actions.Search;
+import com.vk.api.sdk.actions.Secure;
+import com.vk.api.sdk.actions.Stats;
+import com.vk.api.sdk.actions.Status;
+import com.vk.api.sdk.actions.Storage;
+import com.vk.api.sdk.actions.Store;
+import com.vk.api.sdk.actions.Stories;
+import com.vk.api.sdk.actions.Streaming;
+import com.vk.api.sdk.actions.Upload;
+import com.vk.api.sdk.actions.Users;
+import com.vk.api.sdk.actions.Utils;
+import com.vk.api.sdk.actions.Videos;
+import com.vk.api.sdk.actions.Wall;
+import com.vk.api.sdk.actions.Widgets;
+import com.vk.api.sdk.client.TransportClient;
+import org.apache.commons.lang3.StringUtils;
+
+public class VkApiClient {
+    public static final String DEFAULT_API_ADDR = "https://api.vk.com/method/";
+
+    private static final String OAUTH_ENDPOINT = "https://oauth.vk.com/";
+
+    private static final int DEFAULT_RETRY_ATTEMPTS_INTERNAL_SERVER_ERROR_COUNT = 3;
+
+    private String apiVersion = "5.130";
+
+    private TransportClient transportClient;
+
+    private Gson gson;
+
+    private String apiEndpoint;
+
+    private String oauthEndpoint;
+
+    private int retryAttemptsInternalServerErrorCount;
+
+    public VkApiClient(TransportClient transportClient) {
+        this(transportClient, new GsonBuilder().disableHtmlEscaping().create(), DEFAULT_RETRY_ATTEMPTS_INTERNAL_SERVER_ERROR_COUNT);
+    }
+
+    public VkApiClient(TransportClient transportClient, Gson gson,
+                       int retryAttemptsInternalServerErrorCount) {
+        this.transportClient = transportClient;
+        this.gson = gson;
+        this.retryAttemptsInternalServerErrorCount = retryAttemptsInternalServerErrorCount;
+
+        if (StringUtils.isNoneEmpty(System.getProperty("api.host"))) {
+            apiEndpoint = "https://" + System.getProperty("api.host") + "/method/";
+        } else {
+            apiEndpoint = DEFAULT_API_ADDR;
+        }
+
+        if (StringUtils.isNoneEmpty(System.getProperty("oauth.host"))) {
+            oauthEndpoint = "https://" + System.getProperty("oauth.host") + "/";
+        } else {
+            oauthEndpoint = OAUTH_ENDPOINT;
+        }
+    }
+
+    public TransportClient getTransportClient() {
+        return transportClient;
+    }
+
+    public Gson getGson() {
+        return gson;
+    }
+
+    public int getRetryAttemptsInternalServerErrorCount() {
+        return retryAttemptsInternalServerErrorCount;
+    }
+
+    public String getApiEndpoint() {
+        return apiEndpoint;
+    }
+
+    public void setApiEndpoint(String apiEndpoint) {
+        this.apiEndpoint = apiEndpoint;
+    }
+
+    public String getOAuthEndpoint() {
+        return oauthEndpoint;
+    }
+
+    public String getVersion() {
+        return apiVersion;
+    }
+
+    public void setVersion(String version) {
+        this.apiVersion = version;
+    }
+
+    public Account account() {
+        return new Account(this);
+    }
+
+    public Orders orders() {
+        return new Orders(this);
+    }
+
+    public Wall wall() {
+        return new Wall(this);
+    }
+
+    public Execute execute() {
+        return new Execute(this);
+    }
+
+    public Friends friends() {
+        return new Friends(this);
+    }
+
+    public LongPoll longPoll() {
+        return new LongPoll(this);
+    }
+
+    public Store store() {
+        return new Store(this);
+    }
+
+    public Upload upload() {
+        return new Upload(this);
+    }
+
+    public Users users() {
+        return new Users(this);
+    }
+
+    public Apps apps() {
+        return new Apps(this);
+    }
+
+    public Videos videos() {
+        return new Videos(this);
+    }
+
+    public Photos photos() {
+        return new Photos(this);
+    }
+
+    public Ads ads() {
+        return new Ads(this);
+    }
+
+    public Board board() {
+        return new Board(this);
+    }
+
+    public Widgets widgets() {
+        return new Widgets(this);
+    }
+
+    public GroupsLongPoll groupsLongPoll() {
+        return new GroupsLongPoll(this);
+    }
+
+    public Groups groups() {
+        return new Groups(this);
+    }
+
+    public Auth auth() {
+        return new Auth(this);
+    }
+
+    public Newsfeed newsfeed() {
+        return new Newsfeed(this);
+    }
+
+    public Search search() {
+        return new Search(this);
+    }
+
+    public AppWidgets appWidgets() {
+        return new AppWidgets(this);
+    }
+
+    public Database database() {
+        return new Database(this);
+    }
+
+    public Stories stories() {
+        return new Stories(this);
+    }
+
+    public Notes notes() {
+        return new Notes(this);
+    }
+
+    public Status status() {
+        return new Status(this);
+    }
+
+    public Streaming streaming() {
+        return new Streaming(this);
+    }
+
+    public Messages messages() {
+        return new Messages(this);
+    }
+
+    public Fave fave() {
+        return new Fave(this);
+    }
+
+    public Market market() {
+        return new Market(this);
+    }
+
+    public OAuth oAuth() {
+        return new OAuth(this);
+    }
+
+    public Polls polls() {
+        return new Polls(this);
+    }
+
+    public Pages pages() {
+        return new Pages(this);
+    }
+
+    public Storage storage() {
+        return new Storage(this);
+    }
+
+    public Utils utils() {
+        return new Utils(this);
+    }
+
+    public Secure secure() {
+        return new Secure(this);
+    }
+
+    public Stats stats() {
+        return new Stats(this);
+    }
+
+    public Gifts gifts() {
+        return new Gifts(this);
+    }
+
+    public Docs docs() {
+        return new Docs(this);
+    }
+
+    public Likes likes() {
+        return new Likes(this);
+    }
+
+    public Notifications notifications() {
+        return new Notifications(this);
+    }
+}
diff --git a/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkBotRequest.kt b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkBotRequest.kt
new file mode 100644
index 00000000..307b85de
--- /dev/null
+++ b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkBotRequest.kt
@@ -0,0 +1,149 @@
+package com.justai.jaicf.channel.vk
+
+import com.justai.jaicf.api.BotRequest
+import com.justai.jaicf.api.EventBotRequest
+import com.justai.jaicf.api.QueryBotRequest
+import com.vk.api.sdk.objects.audio.Audio
+import com.vk.api.sdk.objects.base.Geo
+import com.vk.api.sdk.objects.base.Sticker
+import com.vk.api.sdk.objects.docs.Doc
+import com.vk.api.sdk.objects.messages.AudioMessage
+import com.vk.api.sdk.objects.messages.Message
+import com.vk.api.sdk.objects.messages.MessageAttachment
+import com.vk.api.sdk.objects.messages.MessageAttachmentType
+import com.vk.api.sdk.objects.photos.Photo
+import com.vk.api.sdk.objects.video.Video
+
+val VkBotRequest.audio get() = this as? VkAudioBotRequest
+val VkBotRequest.document get() = this as? VkDocumentBotRequest
+val VkBotRequest.photo get() = this as? VkPhotoBotRequest
+val VkBotRequest.video get() = this as? VkVideoBotRequest
+val VkBotRequest.location get() = this as? VkLocationBotRequest
+val VkBotRequest.sticker get() = this as? VkStickerBotRequest
+val VkBotRequest.audioMessage get() = this as? VkAudioMessageBotRequest
+val VkBotRequest.multipleAttachments get() = this as? VkMultipleAttachmentsBotRequest
+
+@Suppress("unused")
+interface VkBotRequest : BotRequest {
+    val message: Message
+    val attachments: List<MessageAttachment>
+        get() = message.attachments ?: emptyList()
+}
+
+typealias VKMessageConverter = (Message) -> VkBotRequest?
+
+object VkBotRequestFactory {
+
+    private val customConverters: MutableList<VKMessageConverter> = mutableListOf()
+
+    fun getRequestForMessage(message: Message): VkBotRequest? {
+        message.text = message.text.withoutVkGroupMentions().trim()
+
+        if (message.text.isNotEmpty()) {
+            return VkQueryBotRequest(message)
+        }
+
+        customConverters.forEach { converter ->
+            converter(message)?.let { return it }
+        }
+
+        message.geo?.let { return VkLocationBotRequest(message) }
+
+        return when {
+            message.hasAudio() -> {
+                if (message.hasOtherExcept(MessageAttachmentType.AUDIO)) VkMultipleAttachmentsBotRequest(message)
+                else VkAudioBotRequest(message)
+            }
+            message.hasDocument() -> {
+                if (message.hasOtherExcept(MessageAttachmentType.DOC)) VkMultipleAttachmentsBotRequest(message)
+                else VkDocumentBotRequest(message)
+            }
+            message.hasPhoto() -> {
+                if (message.hasOtherExcept(MessageAttachmentType.PHOTO)) VkMultipleAttachmentsBotRequest(message)
+                else VkPhotoBotRequest(message)
+
+            }
+            message.hasVideo() -> {
+                if (message.hasOtherExcept(MessageAttachmentType.VIDEO)) VkMultipleAttachmentsBotRequest(message)
+                else VkVideoBotRequest(message)
+            }
+            message.hasSticker() -> VkStickerBotRequest(message)
+            message.hasAudioMessage() -> VkAudioMessageBotRequest(message)
+            else -> null
+        }
+    }
+
+    fun registerConverter(converter: VKMessageConverter) = customConverters.add(converter)
+}
+
+private val GROUP_PREFIX_REGEXP = "\\[club[0-9]+\\|\\@public[0-9]+\\]".toRegex()
+private fun String.withoutVkGroupMentions(): String = GROUP_PREFIX_REGEXP.replaceFirst(this, "")
+
+data class VkQueryBotRequest(
+    override val message: Message
+) : VkBotRequest, QueryBotRequest(message.clientId, message.text)
+
+data class VkAudioBotRequest(
+    override val message: Message,
+    val audios: List<Audio> = message.audios
+) : VkBotRequest, EventBotRequest(message.clientId, VkEvent.AUDIO)
+
+data class VkDocumentBotRequest(
+    override val message: Message,
+    val documents: List<Doc> = message.documents
+) : VkBotRequest, EventBotRequest(message.clientId, VkEvent.DOCUMENT)
+
+data class VkPhotoBotRequest(
+    override val message: Message,
+    val photos: List<Photo> = message.photos
+) : VkBotRequest, EventBotRequest(message.clientId, VkEvent.PHOTO)
+
+data class VkVideoBotRequest(
+    override val message: Message,
+    val videos: List<Video> = message.videos
+) : VkBotRequest, EventBotRequest(message.clientId, VkEvent.VIDEO)
+
+data class VkLocationBotRequest(
+    override val message: Message,
+    val geo: Geo = message.geo
+) : VkBotRequest, EventBotRequest(message.clientId, VkEvent.LOCATION)
+
+data class VkStickerBotRequest(
+    override val message: Message,
+    val stickers: List<Sticker> = message.stickers
+) : VkBotRequest, EventBotRequest(message.clientId, VkEvent.STICKER)
+
+data class VkAudioMessageBotRequest(
+    override val message: Message,
+    val audioMessages: List<AudioMessage> = message.audioMessage
+) : VkBotRequest, EventBotRequest(message.clientId, VkEvent.AUDIO_MESSAGE)
+
+data class VkMultipleAttachmentsBotRequest(
+    override val message: Message,
+    val audios: List<Audio> = message.attachments.mapNotNull { it.audio },
+    val documents: List<Doc> = message.attachments.mapNotNull { it.doc },
+    val photos: List<Photo> = message.attachments.mapNotNull { it.photo },
+    val files: List<Video> = message.attachments.mapNotNull { it.video }
+) : VkBotRequest, EventBotRequest(message.clientId, VkEvent.MULTIPLE_ATTACHMENTS)
+
+private val Message.clientId get() = peerId.toString()
+
+private fun Message.hasAudio() = audios.any()
+private val Message.audios get() = attachments.mapNotNull { it.audio }
+
+private fun Message.hasDocument() = documents.any()
+private val Message.documents get() = attachments.mapNotNull { it.doc }
+
+private fun Message.hasPhoto() = photos.any()
+private val Message.photos get() = attachments.mapNotNull { it.photo }
+
+private fun Message.hasVideo() = videos.any()
+private val Message.videos get() = attachments.mapNotNull { it.video }
+
+private fun Message.hasSticker() = stickers.any()
+private val Message.stickers get() = attachments.mapNotNull { it.sticker }
+
+private fun Message.hasAudioMessage() = audioMessage.any()
+private val Message.audioMessage get() = attachments.mapNotNull { it.audioMessage }
+
+private fun Message.hasOtherExcept(type: MessageAttachmentType) = attachments.any { it.type != type }
\ No newline at end of file
diff --git a/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkChannel.kt b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkChannel.kt
new file mode 100644
index 00000000..90a3c43e
--- /dev/null
+++ b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkChannel.kt
@@ -0,0 +1,69 @@
+package com.justai.jaicf.channel.vk
+
+import com.justai.jaicf.api.BotApi
+import com.justai.jaicf.channel.http.HttpBotRequest
+import com.justai.jaicf.channel.http.HttpBotResponse
+import com.justai.jaicf.channel.jaicp.JaicpCompatibleAsyncBotChannel
+import com.justai.jaicf.channel.jaicp.JaicpCompatibleAsyncChannelFactory
+import com.justai.jaicf.channel.jaicp.JaicpLiveChatProvider
+import com.justai.jaicf.context.RequestContext
+import com.justai.jaicf.helpers.logging.WithLogger
+import com.vk.api.sdk.callback.CallbackApi
+import com.vk.api.sdk.callback.longpoll.CallbackApiLongPoll
+import com.vk.api.sdk.client.VkApiClient
+import com.vk.api.sdk.client.actors.GroupActor
+import com.vk.api.sdk.httpclient.HttpTransportClient
+import com.vk.api.sdk.objects.messages.Message
+import java.util.concurrent.Executors
+
+class VkChannel(
+    override val botApi: BotApi,
+    configuration: VkChannelConfiguration,
+    apiEndpoint: String = VkApiClient.DEFAULT_API_ADDR
+) : JaicpCompatibleAsyncBotChannel, WithLogger, CallbackApi() {
+
+    private val transportClient = HttpTransportClient.getInstance()
+    private val vk = VkApiClient(transportClient).apply { this.apiEndpoint = apiEndpoint }
+    private val group: GroupActor = GroupActor(configuration.groupId, configuration.accessToken)
+    private val storage = configuration.reactionsContentStorage
+
+    override fun messageNew(groupId: Int, message: Message) {
+        process(message)
+    }
+
+    override fun process(request: HttpBotRequest): HttpBotResponse {
+        parse(request.receiveText())
+        return HttpBotResponse.accepted()
+    }
+
+    private fun process(message: Message) = VkBotRequestFactory.getRequestForMessage(message)
+        ?.let { process(it) }
+        ?: logger.debug("No request converter found for message: $message")
+
+    private fun process(request: VkBotRequest): HttpBotResponse {
+        val reactions = VkReactions(vk, group, request, storage)
+        botApi.process(request, reactions, RequestContext.DEFAULT)
+        return HttpBotResponse.accepted()
+    }
+
+    companion object : JaicpCompatibleAsyncChannelFactory {
+        private const val TOKEN = "temporary-access-token"
+        private const val GROUP_ID = 0
+        override val channelType = "vk"
+
+        override fun create(
+            botApi: BotApi,
+            apiUrl: String,
+            liveChatProvider: JaicpLiveChatProvider
+        ): JaicpCompatibleAsyncBotChannel =
+            VkChannel(botApi, VkChannelConfiguration(TOKEN, GROUP_ID), "$apiUrl/")
+    }
+
+    fun runBlocking() = object : CallbackApiLongPoll(vk, group) {
+        private val executor = Executors.newWorkStealingPool()
+
+        override fun messageNew(groupId: Int, message: Message) {
+            executor.submit { this@VkChannel.messageNew(groupId, message) }
+        }
+    }.run()
+}
diff --git a/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkChannelConfiguration.kt b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkChannelConfiguration.kt
new file mode 100644
index 00000000..f73721e4
--- /dev/null
+++ b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkChannelConfiguration.kt
@@ -0,0 +1,17 @@
+package com.justai.jaicf.channel.vk
+
+import com.justai.jaicf.channel.vk.api.InMemoryVkContentStorage
+import com.justai.jaicf.channel.vk.api.VkReactionsContentStorage
+
+/**
+ * Configuration for VK Channel
+ *
+ * @param accessToken token to access VK API
+ * @param groupId chat-bot's group identifier
+ * @param reactionsContentStorage storage to persist audio/image/document identifiers sent by reactions. Default implementation is [InMemoryVkContentStorage].
+ * */
+data class VkChannelConfiguration(
+    val accessToken: String,
+    val groupId: Int,
+    val reactionsContentStorage: VkReactionsContentStorage = InMemoryVkContentStorage
+)
diff --git a/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkEvent.kt b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkEvent.kt
new file mode 100644
index 00000000..1085cbb1
--- /dev/null
+++ b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkEvent.kt
@@ -0,0 +1,12 @@
+package com.justai.jaicf.channel.vk
+
+object VkEvent {
+    const val LOCATION = "location"
+    const val AUDIO_MESSAGE = "audio_message"
+    const val MULTIPLE_ATTACHMENTS = "attachments"
+    const val DOCUMENT = "document"
+    const val AUDIO = "audio"
+    const val PHOTO = "photo"
+    const val STICKER = "sticker"
+    const val VIDEO = "video"
+}
\ No newline at end of file
diff --git a/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkReactions.kt b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkReactions.kt
new file mode 100644
index 00000000..60bc6c55
--- /dev/null
+++ b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkReactions.kt
@@ -0,0 +1,140 @@
+package com.justai.jaicf.channel.vk
+
+import com.justai.jaicf.channel.vk.api.InMemoryVkContentStorage
+import com.justai.jaicf.channel.vk.api.VkReactionsContentStorage
+import com.justai.jaicf.logging.AudioReaction
+import com.justai.jaicf.logging.ButtonsReaction
+import com.justai.jaicf.logging.FileReaction
+import com.justai.jaicf.logging.ImageReaction
+import com.justai.jaicf.logging.SayReaction
+import com.justai.jaicf.logging.VideoReaction
+import com.justai.jaicf.reactions.Reactions
+import com.vk.api.sdk.client.VkApiClient
+import com.vk.api.sdk.client.actors.GroupActor
+import com.vk.api.sdk.objects.docs.GetMessagesUploadServerType
+import com.vk.api.sdk.objects.messages.Keyboard
+import com.vk.api.sdk.objects.messages.KeyboardButton
+import com.vk.api.sdk.objects.messages.KeyboardButtonAction
+import com.vk.api.sdk.objects.messages.TemplateActionTypeNames
+import java.io.File
+import java.util.*
+
+val Reactions.vk
+    get() = this as? VkReactions
+
+
+@Suppress("unused", "MemberVisibilityCanBePrivate")
+class VkReactions(
+    val api: VkApiClient,
+    val actor: GroupActor,
+    private val request: VkBotRequest,
+    private val storage: VkReactionsContentStorage = InMemoryVkContentStorage
+) : Reactions() {
+
+    val peerId: Int = request.clientId.toInt()
+
+    private val messageTemplate get() = api.messages().send(actor).peerId(peerId).randomId(random.nextInt())
+
+    companion object {
+        private val random = Random()
+    }
+
+    override fun say(text: String): SayReaction {
+        sendMessage(text, emptyList())
+        return SayReaction.create(text)
+    }
+
+    fun say(text: String, vararg buttons: String) {
+        sendMessage(
+            text, buttons.map { buttonText ->
+                KeyboardButton().apply {
+                    action = KeyboardButtonAction().apply {
+                        type = TemplateActionTypeNames.CALLBACK
+                        label = buttonText
+                        payload = "{}"
+                    }
+                }
+            }.chunked(4) // we chunk because vk api allows max to 4 buttons in a single row
+        )
+
+        SayReaction.create(text)
+        ButtonsReaction.create(buttons.asList())
+    }
+
+    override fun image(url: String): ImageReaction {
+        messageTemplate.attachment(storage.getOrUploadImage(api, actor, peerId, url)).execute()
+        return ImageReaction.create(url)
+    }
+
+    fun image(file: File): ImageReaction {
+        messageTemplate.attachment(storage.getOrUploadImage(api, actor, peerId, file))
+        return ImageReaction.create(file.absolutePath)
+    }
+
+    fun image(ownerId: Int, mediaId: Int, accessKey: Int? = null): ImageReaction {
+        val imageId = when (accessKey) {
+            null -> "photo${ownerId}_$mediaId"
+            else -> "photo${ownerId}_${mediaId}_$accessKey"
+        }
+        messageTemplate.attachment(imageId).execute()
+        return ImageReaction.create(imageId)
+    }
+
+    override fun audio(url: String): AudioReaction {
+        val audio = storage.getOrUploadUrl(api, actor, peerId, url, GetMessagesUploadServerType.AUDIO_MESSAGE) {
+            "doc${audioMessage.ownerId}_${audioMessage.id}"
+        }
+        messageTemplate.attachment(audio).execute()
+        return AudioReaction.create(url)
+    }
+
+    fun audio(file: File): AudioReaction {
+        val audio = storage.getOrUploadFile(api, actor, peerId, file, GetMessagesUploadServerType.AUDIO_MESSAGE) {
+            "doc${audioMessage.ownerId}_${audioMessage.id}"
+        }
+        messageTemplate.attachment(audio).execute()
+        return AudioReaction.create(file.absolutePath)
+    }
+
+    fun audio(ownerId: Int, mediaId: Int, accessKey: Int? = null): AudioReaction {
+        val audioId = when (accessKey) {
+            null -> "audio${ownerId}_$mediaId"
+            else -> "audio${ownerId}_${mediaId}_$accessKey"
+        }
+        messageTemplate.attachment(audioId).execute()
+        return AudioReaction.create(audioId)
+    }
+
+    fun video(ownerId: Int, mediaId: Int, accessKey: Int? = null): VideoReaction {
+        val videoId = when (accessKey) {
+            null -> "video${ownerId}_$mediaId"
+            else -> "video${ownerId}_${mediaId}_$accessKey"
+        }
+        messageTemplate.attachment(videoId).execute()
+        return VideoReaction.create(videoId)
+    }
+
+    fun document(file: File): FileReaction {
+        val uploaded = storage.getOrUploadFile(api, actor, peerId, file, GetMessagesUploadServerType.DOC) { "doc${doc.ownerId}_${doc.id}" }
+        messageTemplate.attachment(uploaded).execute()
+        return FileReaction.create(file.absolutePath)
+    }
+
+    fun document(url: String): FileReaction {
+        val uploaded = storage.getOrUploadUrl(api, actor, peerId, url, GetMessagesUploadServerType.DOC) { "doc${doc.ownerId}_${doc.id}" }
+        messageTemplate.attachment(uploaded).execute()
+        return FileReaction.create(url)
+    }
+
+    fun document(ownerId: Int, mediaId: Int, accessKey: Int? = null): FileReaction {
+        val documentId = when (accessKey) {
+            null -> "doc${ownerId}_$mediaId"
+            else -> "doc${ownerId}_${mediaId}_$accessKey"
+        }
+        messageTemplate.attachment(documentId).execute()
+        return FileReaction.create(documentId)
+    }
+
+    private fun sendMessage(text: String, buttons: List<List<KeyboardButton>>) =
+        messageTemplate.message(text).keyboard(Keyboard().setButtons(buttons)).execute()
+}
diff --git a/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkTypeToken.kt b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkTypeToken.kt
new file mode 100644
index 00000000..2eaa7e0e
--- /dev/null
+++ b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/VkTypeToken.kt
@@ -0,0 +1,7 @@
+package com.justai.jaicf.channel.vk
+
+import com.justai.jaicf.generic.ChannelTypeToken
+
+typealias VkTypeToken = ChannelTypeToken<VkBotRequest, VkReactions>
+
+val vk: VkTypeToken = ChannelTypeToken()
diff --git a/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/api/InMemoryVkContentStorage.kt b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/api/InMemoryVkContentStorage.kt
new file mode 100644
index 00000000..c93e8010
--- /dev/null
+++ b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/api/InMemoryVkContentStorage.kt
@@ -0,0 +1,51 @@
+package com.justai.jaicf.channel.vk.api
+
+import com.vk.api.sdk.client.VkApiClient
+import com.vk.api.sdk.client.actors.GroupActor
+import com.vk.api.sdk.objects.docs.GetMessagesUploadServerType
+import com.vk.api.sdk.objects.docs.responses.SaveResponse
+import java.io.File
+import java.util.concurrent.ConcurrentHashMap
+
+
+/**
+ * In-memory implementation of [VkReactionsContentStorage] to persist image/document or audio identifiers sent by reactions.
+ * */
+object InMemoryVkContentStorage : VkReactionsContentStorage {
+    private val uploadedUrlResourcesMap = ConcurrentHashMap<String, String>()
+    private val uploadedFileResourcesMap = ConcurrentHashMap<File, String>()
+
+    override fun getOrUploadImage(api: VkApiClient, actor: GroupActor, peerId: Int, url: String): String =
+        uploadedUrlResourcesMap.getOrPut(url) {
+            uploadPhoto(api, actor, uploadResourceToFile(url, "image", "jpeg"))
+        }
+
+    override fun getOrUploadImage(api: VkApiClient, actor: GroupActor, peerId: Int, file: File): String =
+        uploadedFileResourcesMap.getOrPut(file) {
+            uploadPhoto(api, actor, file)
+        }
+
+    override fun getOrUploadUrl(
+        api: VkApiClient,
+        groupActor: GroupActor,
+        peerId: Int,
+        url: String,
+        type: GetMessagesUploadServerType,
+        identityKeyProvider: (SaveResponse) -> String
+    ): String = uploadedUrlResourcesMap.getOrPut(url) {
+        identityKeyProvider(
+            uploadDocument(api, groupActor, peerId, uploadResourceToFile(url, type.value, "doc"), type)
+        )
+    }
+
+    override fun getOrUploadFile(
+        api: VkApiClient,
+        groupActor: GroupActor,
+        peerId: Int,
+        file: File,
+        type: GetMessagesUploadServerType,
+        identityKeyProvider: (SaveResponse) -> String
+    ): String = uploadedFileResourcesMap.getOrPut(file) {
+        identityKeyProvider(uploadDocument(api, groupActor, peerId, file, type))
+    }
+}
\ No newline at end of file
diff --git a/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/api/VkReactionsContentStorage.kt b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/api/VkReactionsContentStorage.kt
new file mode 100644
index 00000000..ecb0ef1a
--- /dev/null
+++ b/channels/vk/src/main/kotlin/com/justai/jaicf/channel/vk/api/VkReactionsContentStorage.kt
@@ -0,0 +1,105 @@
+package com.justai.jaicf.channel.vk.api
+
+import com.vk.api.sdk.client.VkApiClient
+import com.vk.api.sdk.client.actors.GroupActor
+import com.vk.api.sdk.objects.docs.GetMessagesUploadServerType
+import com.vk.api.sdk.objects.docs.responses.SaveResponse
+import org.apache.commons.io.FilenameUtils
+import org.apache.http.client.methods.HttpGet
+import org.apache.http.impl.client.HttpClientBuilder
+import java.io.File
+import java.net.URI
+
+/**
+ * Defines a storage to save image, document or audio identifiers to send in VK Reactions.
+ *
+ * @see InMemoryVkContentStorage in memory storage implementation.
+ * */
+interface VkReactionsContentStorage {
+
+    /**
+     * Get image from storage by url or upload it to VK servers and return String-identifier to send in reaction
+     * */
+    fun getOrUploadImage(
+        api: VkApiClient,
+        actor: GroupActor,
+        peerId: Int,
+        url: String
+    ): String
+
+    /**
+     * Get image from storage by file or upload it to VK servers and return String-identifier to send in reaction
+     * */
+    fun getOrUploadImage(
+        api: VkApiClient,
+        actor: GroupActor,
+        peerId: Int,
+        file: File
+    ): String
+
+    /**
+     * Get document from storage by url or upload it to VK servers and return String-identifier to send in reaction
+     * */
+    fun getOrUploadUrl(
+        api: VkApiClient,
+        groupActor: GroupActor,
+        peerId: Int,
+        url: String,
+        type: GetMessagesUploadServerType,
+        identityKeyProvider: SaveResponse.() -> String
+    ): String
+
+    /**
+     * Get document from storage by file or upload it to VK servers and return String-identifier to send in reaction
+     * */
+    fun getOrUploadFile(
+        api: VkApiClient,
+        groupActor: GroupActor,
+        peerId: Int,
+        file: File,
+        type: GetMessagesUploadServerType,
+        identityKeyProvider: SaveResponse.() -> String
+    ): String?
+}
+
+private val httpClient = HttpClientBuilder.create().build()
+
+private fun String.orIfEmpty(other: String) = if (isNullOrEmpty()) other else this
+
+fun VkReactionsContentStorage.uploadResourceToFile(url: String, prefix: String, defaultExtension: String): File {
+    val ext = FilenameUtils.getExtension(url).orIfEmpty(defaultExtension)
+    val file = File.createTempFile(prefix, "vk_upload.$ext")
+    httpClient.execute(HttpGet(URI(url))).use {
+        file.writeBytes(it.entity.content.readBytes())
+    }
+    return file
+}
+
+fun VkReactionsContentStorage.uploadPhoto(
+    vkApiClient: VkApiClient,
+    groupActor: GroupActor,
+    file: File
+): String {
+    val uploadUrl = vkApiClient.photos().getMessagesUploadServer(groupActor).execute().uploadUrl.toString()
+    val uploadResponse = vkApiClient.upload().photoMessage(uploadUrl, file).execute()
+    val photo = vkApiClient.photos().saveMessagesPhoto(groupActor, uploadResponse.photo)
+        .server(uploadResponse.server)
+        .hash(uploadResponse.hash).execute()
+        .first()
+    return "photo${photo.ownerId}_${photo.id}"
+}
+
+fun VkReactionsContentStorage.uploadDocument(
+    vkApiClient: VkApiClient,
+    groupActor: GroupActor,
+    peerId: Int,
+    file: File,
+    type: GetMessagesUploadServerType
+): SaveResponse {
+    val uploadUrl = vkApiClient.docs().getMessagesUploadServer(groupActor)
+        .type(type)
+        .peerId(peerId)
+        .execute().uploadUrl.toString()
+    val docUploadResponse = vkApiClient.upload().doc(uploadUrl, file).execute()
+    return vkApiClient.docs().save(groupActor, docUploadResponse.file).execute()
+}
\ No newline at end of file
diff --git a/settings.gradle.kts b/settings.gradle.kts
index de768a0a..8605d010 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -24,8 +24,6 @@ include("channels:slack")
 findProject(":channels:slack")?.name = "slack"
 include("channels:telegram")
 findProject(":channels:telegram")?.name = "telegram"
-include("channels:viber")
-findProject(":channels:viber")?.name = "viber"
 include("channels:google-actions")
 findProject(":channels:google-actions")?.name = "google-actions"
 include("channels:jaicp")
@@ -45,3 +43,5 @@ include("channels:yandex-alice")
 findProject(":channels:yandex-alice")?.name = "yandex-alice"
 include("channels:viber")
 findProject(":channels:viber")?.name = "viber"
+include("channels:vk")
+findProject(":channels:vk")?.name = "vk"