diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 00000000..fa2e267c
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,5 @@
+blank_issues_enabled: true
+contact_links:
+  - name: Discord Server
+    url: https://discord.com/invite/SPE3npH7Wu
+    about: A small community to help you with your issues.
\ No newline at end of file
diff --git a/app/ui/package.json b/app/ui/package.json
index daabe64e..96004471 100644
--- a/app/ui/package.json
+++ b/app/ui/package.json
@@ -1,7 +1,7 @@
 {
   "name": "app",
   "private": true,
-  "version": "1.4.3",
+  "version": "1.4.4",
   "type": "module",
   "scripts": {
     "dev": "vite",
diff --git a/app/ui/src/components/Bot/Conversation/ConversationSidebar.tsx b/app/ui/src/components/Bot/Conversation/ConversationSidebar.tsx
index 6225d28b..707cce9a 100644
--- a/app/ui/src/components/Bot/Conversation/ConversationSidebar.tsx
+++ b/app/ui/src/components/Bot/Conversation/ConversationSidebar.tsx
@@ -11,10 +11,14 @@ export const ConversationSidebar = ({
   data,
   defaultIndex,
   setDefaultIndex,
+  onChannelChange,
+  defaultChannel,
 }: {
   data: ConversationsByType[];
   defaultIndex: number | null;
   setDefaultIndex: React.Dispatch<React.SetStateAction<number | null>>;
+  onChannelChange: (value: string) => void;
+  defaultChannel: string;
 }) => {
   const [hideMenu] = React.useState(false);
   return (
@@ -31,8 +35,14 @@ export const ConversationSidebar = ({
               <div className="flex flex-col gap-2">
                 <h2 className="text-lg font-semibold">Conversations</h2>
                 <Select
-                  options={[{ label: "Website", value: "website" }]}
-                  defaultValue="website"
+                  options={[
+                    { label: "Website", value: "website" },
+                    { label: "Telegram", value: "telegram" },
+                    { label: "Discord", value: "discord" },
+                    // { label: "WhatsApp", value: "whatsapp" },
+                  ]}
+                  onChange={(value) => onChannelChange(value)}
+                  defaultValue={defaultChannel}
                   style={{ width: "100%" }}
                 />
               </div>
@@ -59,7 +69,7 @@ export const ConversationSidebar = ({
                             : `Anonymous`}
                         </h3>
                         <span className="text-xs font-thin">
-                          {dayjs(item?.created_at).fromNow()}
+                          {item?.created_at && dayjs(item?.created_at).fromNow()}
                         </span>
                       </div>
                       <div className="flex mt-2  flex-col gap-1">
diff --git a/app/ui/src/components/Bot/Conversation/index.tsx b/app/ui/src/components/Bot/Conversation/index.tsx
index 6c6b5e0f..7af59d83 100644
--- a/app/ui/src/components/Bot/Conversation/index.tsx
+++ b/app/ui/src/components/Bot/Conversation/index.tsx
@@ -3,7 +3,15 @@ import React from "react";
 import { ConversationSidebar } from "./ConversationSidebar";
 import { ConversationInfo } from "./ConversationInfo";
 
-export const ConversationBody = ({ data }: { data: ConversationsByType[] }) => {
+export const ConversationBody = ({
+  data,
+  setType,
+  type,
+}: {
+  data: ConversationsByType[];
+  type: string;
+  setType: React.Dispatch<React.SetStateAction<string>>;
+}) => {
   const [defaultIndex, setDefaultIndex] = React.useState<number | null>(null);
 
   React.useEffect(() => {
@@ -19,6 +27,11 @@ export const ConversationBody = ({ data }: { data: ConversationsByType[] }) => {
           defaultIndex={defaultIndex}
           setDefaultIndex={setDefaultIndex}
           data={data}
+          defaultChannel={type}
+          onChannelChange={(value) => {
+            setDefaultIndex(null);
+            setType(value);
+          }}
         />
       </div>
       <div className="md:ml-[350px]">
diff --git a/app/ui/src/components/Common/SkeletonLoading.tsx b/app/ui/src/components/Common/SkeletonLoading.tsx
index df2ee714..3ee985d8 100644
--- a/app/ui/src/components/Common/SkeletonLoading.tsx
+++ b/app/ui/src/components/Common/SkeletonLoading.tsx
@@ -1,10 +1,10 @@
 import { Skeleton } from "antd";
 
-export const SkeletonLoading = () => {
+export const SkeletonLoading = ({ className = "mt-6" }: { className?: string }) => {
   return (
-    <>
+    <div className={className}>
       <Skeleton active />
       <Skeleton active className="mt-3" />
-    </>
+    </div>
   );
 };
diff --git a/app/ui/src/routes/bot/conversations.tsx b/app/ui/src/routes/bot/conversations.tsx
index 0a09694f..b232d7da 100644
--- a/app/ui/src/routes/bot/conversations.tsx
+++ b/app/ui/src/routes/bot/conversations.tsx
@@ -14,20 +14,17 @@ export default function BotConversationsRoot() {
     conversation_id?: string;
   }>();
   const navigate = useNavigate();
-  const [defaultType] = React.useState<string>(param.type || "website");
+  const [type, setType] = React.useState<string>(param.type || "website");
   const { data, status } = useQuery(
-    ["getBotConversations", param.id, param.type],
+    ["getBotConversations", param.id, param.type, type],
     async () => {
-      const response = await api.get(
-        `/bot/conversations/${param.id}/${defaultType}`
-      );
+      const response = await api.get(`/bot/conversations/${param.id}/${type}`);
       return response.data as {
         data: ConversationsByType[];
       };
     },
     {
       enabled: !!param.id,
-      refetchInterval: 1000,
     }
   );
 
@@ -39,11 +36,13 @@ export default function BotConversationsRoot() {
   return (
     <>
       {status === "loading" && (
-        <div className="p-4 m-3">
-          <SkeletonLoading />
+        <div className="mx-auto my-3 w-full max-w-7xl">
+          <SkeletonLoading className="mt-6" />
         </div>
       )}
-      {status === "success" && <ConversationBody data={data.data} />}
+      {status === "success" && (
+        <ConversationBody setType={setType} type={type} data={data.data} />
+      )}
     </>
   );
 }
diff --git a/app/ui/src/routes/bot/integrations.tsx b/app/ui/src/routes/bot/integrations.tsx
index 19467163..e6c735be 100644
--- a/app/ui/src/routes/bot/integrations.tsx
+++ b/app/ui/src/routes/bot/integrations.tsx
@@ -42,7 +42,6 @@ export default function BotIntegrationRoot() {
     },
     {
       enabled: !!param.id,
-      refetchInterval: 1000,
     }
   );
 
@@ -54,8 +53,7 @@ export default function BotIntegrationRoot() {
 
   return (
     <div className="mx-auto my-3 w-full max-w-7xl">
-
-      {status === "loading" && <SkeletonLoading />}
+      {status === "loading" && <SkeletonLoading className="mt-6" />}
       {status === "success" && <IntegrationGrid data={data.data} />}
     </div>
   );
diff --git a/app/ui/src/routes/bot/playground.tsx b/app/ui/src/routes/bot/playground.tsx
index 8e3a28a5..4847471c 100644
--- a/app/ui/src/routes/bot/playground.tsx
+++ b/app/ui/src/routes/bot/playground.tsx
@@ -33,7 +33,7 @@ export default function BotPreviewRoot() {
   return (
     <>
       {status === "loading" && (
-        <div className="p-4 m-3">
+        <div className="mx-auto my-3 w-full max-w-7xl">
           <SkeletonLoading />
         </div>
       )}
diff --git a/package.json b/package.json
index 90e58ef0..863f5f8e 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "dialoqbase",
-  "version": "1.4.3",
+  "version": "1.4.4",
   "description": "Create chatbots with ease",
   "scripts": {
     "ui:dev": "pnpm run --filter ui dev",
diff --git a/server/src/integration/handlers/discord.handler.ts b/server/src/integration/handlers/discord.handler.ts
index cacb2635..add24406 100644
--- a/server/src/integration/handlers/discord.handler.ts
+++ b/server/src/integration/handlers/discord.handler.ts
@@ -44,6 +44,10 @@ export const discordBotHandler = async (
       ai: message.bot,
     }));
 
+    if (history.length > 20) {
+      history.splice(0, history.length - 20);
+    }
+
     const temperature = bot.temperature;
 
     const sanitizedQuestion = message.trim().replaceAll("\n", " ");
diff --git a/server/src/integration/handlers/telegram.handler.ts b/server/src/integration/handlers/telegram.handler.ts
index ddb26f24..68c65ded 100644
--- a/server/src/integration/handlers/telegram.handler.ts
+++ b/server/src/integration/handlers/telegram.handler.ts
@@ -34,14 +34,14 @@ export const telegramBotHandler = async (
       },
     });
 
-    // if (chat_history.length > 10) {
-    //   chat_history.splice(0, chat_history.length - 10);
-    // }
-
     let history = chat_history.map((message) => ({
       human: message.human,
       ai: message.bot,
     }));
+    
+    if (history.length > 20) {
+      history.splice(0, history.length - 20);
+    }
 
     const temperature = bot.temperature;
 
diff --git a/server/src/integration/handlers/whatsapp.handler.ts b/server/src/integration/handlers/whatsapp.handler.ts
index 4d18c1c9..bedd1ea9 100644
--- a/server/src/integration/handlers/whatsapp.handler.ts
+++ b/server/src/integration/handlers/whatsapp.handler.ts
@@ -43,8 +43,8 @@ export const whatsappBotHandler = async (
       },
     });
 
-    if (chat_history.length > 10) {
-      chat_history.splice(0, chat_history.length - 10);
+    if (chat_history.length > 20) {
+      chat_history.splice(0, chat_history.length - 20);
     }
 
     let history = chat_history.map((message) => ({
diff --git a/server/src/routes/api/v1/bot/conversations/handlers/get.handler.ts b/server/src/routes/api/v1/bot/conversations/handlers/get.handler.ts
index eaa037bf..7602b484 100644
--- a/server/src/routes/api/v1/bot/conversations/handlers/get.handler.ts
+++ b/server/src/routes/api/v1/bot/conversations/handlers/get.handler.ts
@@ -3,41 +3,97 @@ import {
   ChatIntergationHistoryByChatIdRequest,
   ChatIntergationHistoryByTypeRequest,
 } from "./type";
-import { botWebHistory } from "@prisma/client";
+import {
+  botWebHistory,
+  BotTelegramHistory,
+  BotWhatsappHistory,
+  BotDiscordHistory,
+} from "@prisma/client";
 
-const getAllMessagesHelper =  (webHistory: botWebHistory[]) => {
+const getAllMessagesHelper = (
+  webHistory:
+    | botWebHistory[]
+    | BotTelegramHistory[]
+    | BotWhatsappHistory[]
+    | BotDiscordHistory[],
+  type: string = "website"
+) => {
   const messages: {
     isBot: boolean;
     message?: string | null;
     sources?: any;
-    createdAt: Date;
+    createdAt?: Date;
   }[] = [];
-  for (const message of webHistory) {
-    messages.push({
-      isBot: false,
-      message: message.human,
-      sources: null,
-      createdAt: message.createdAt,
-    });
+  if (type === "website") {
+    for (const message of webHistory as botWebHistory[]) {
+      messages.push({
+        isBot: false,
+        message: message.human,
+        sources: null,
+        createdAt: message.createdAt,
+      });
+
+      messages.push({
+        isBot: true,
+        message: message.bot,
+        sources: message.sources,
+        createdAt: message.createdAt,
+      });
+    }
 
-    messages.push({
-      isBot: true,
-      message: message.bot,
-      sources: message.sources,
-      createdAt: message.createdAt,
+    messages.sort((a, b) => {
+      // @ts-ignore
+      return a.createdAt.getTime() - b.createdAt.getTime();
     });
-  }
 
-  messages.sort((a, b) => {
-    return a.createdAt.getTime() - b.createdAt.getTime();
-  });
+    return messages;
+  } else if (type === "telegram") {
+    for (const message of webHistory as BotTelegramHistory[]) {
+      messages.push({
+        isBot: false,
+        message: message.human,
+      });
+
+      messages.push({
+        isBot: true,
+        message: message.bot,
+      });
+    }
+    return messages;
+  } else if (type === "discord") {
+    for (const message of webHistory as BotDiscordHistory[]) {
+      messages.push({
+        isBot: false,
+        message: message.human,
+      });
+
+      messages.push({
+        isBot: true,
+        message: message.bot,
+      });
+    }
+    return messages;
+  } else if (type === "whatsapp") {
+    for (const message of webHistory as BotWhatsappHistory[]) {
+      messages.push({
+        isBot: false,
+        message: message.human,
+      });
+
+      messages.push({
+        isBot: true,
+        message: message.bot,
+      });
+    }
+    return messages;
+  }
 
   return messages;
 };
 
 export const getChatIntergationHistoryByTypeHandler = async (
   request: FastifyRequest<ChatIntergationHistoryByTypeRequest>,
-  reply: FastifyReply,
+  reply: FastifyReply
 ) => {
   const { id, type } = request.params;
   const prisma = request.server.prisma;
@@ -57,24 +113,19 @@ export const getChatIntergationHistoryByTypeHandler = async (
 
   switch (type) {
     case "website":
-      prisma.botWebHistory;
-
       const webHistory = await prisma.botWebHistory.findMany({
         where: {
           bot_id: id,
         },
       });
-      const webHistoyGroupByChatId: Record<string, botWebHistory[]> = webHistory
-        .reduce(
-          (acc, cur) => {
-            if (!acc[cur.chat_id]) {
-              acc[cur.chat_id] = [];
-            }
-            acc[cur.chat_id].push(cur);
-            return acc;
-          },
-          {} as Record<string, botWebHistory[]>,
-        );
+      const webHistoyGroupByChatId: Record<string, botWebHistory[]> =
+        webHistory.reduce((acc, cur) => {
+          if (!acc[cur.chat_id]) {
+            acc[cur.chat_id] = [];
+          }
+          acc[cur.chat_id].push(cur);
+          return acc;
+        }, {} as Record<string, botWebHistory[]>);
 
       const result = Object.keys(webHistoyGroupByChatId).map((key) => {
         return {
@@ -90,12 +141,172 @@ export const getChatIntergationHistoryByTypeHandler = async (
         return (
           new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
         );
-      }); 
+      });
       return reply.status(200).send({
         message: "Success",
         data: result,
       });
 
+    case "telegram":
+      const process_tg = await prisma.botIntegration.findFirst({
+        where: {
+          bot_id: id,
+          provider: "telegram",
+        },
+      });
+      if (!process_tg) {
+        return reply.status(200).send({
+          message: "Success",
+          data: [],
+        });
+      }
+
+      const telegramHistory = await prisma.botTelegramHistory.findMany({
+        where: {
+          identifier: process_tg.identifier,
+        },
+      });
+      console.log(telegramHistory);
+
+      // group by chat_id
+      const telegramHistoryGroupByChatId: Record<string, BotTelegramHistory[]> =
+        telegramHistory
+          .filter((item) => item.new_chat_id)
+          .reduce((acc, cur) => {
+            if (cur && cur.new_chat_id) {
+              if (!acc[cur.new_chat_id]) {
+                acc[cur.new_chat_id] = [];
+              }
+              acc[cur.new_chat_id].push(cur);
+            }
+            return acc;
+          }, {} as Record<string, BotTelegramHistory[]>);
+
+      const telegramResult = Object.keys(telegramHistoryGroupByChatId).map(
+        (key) => {
+          return {
+            chat_id: key,
+            human: telegramHistoryGroupByChatId[key][0].human,
+            bot: telegramHistoryGroupByChatId[key][0].bot,
+            all_messages: getAllMessagesHelper(
+              telegramHistoryGroupByChatId[key],
+              "telegram"
+            ),
+          };
+        }
+      );
+
+      return reply.status(200).send({
+        message: "Success",
+        data: telegramResult,
+      });
+
+    case "discord":
+      const process_discord = await prisma.botIntegration.findFirst({
+        where: {
+          bot_id: id,
+          provider: "discord",
+        },
+      });
+      if (!process_discord) {
+        return reply.status(200).send({
+          message: "Success",
+          data: [],
+        });
+      }
+
+      const discordHistory = await prisma.botDiscordHistory.findMany({
+        where: {
+          identifier: process_discord.identifier,
+        },
+      });
+
+      // group by chat_id
+      const discordHistoryGroupByChatId: Record<string, BotDiscordHistory[]> =
+        discordHistory
+          .filter((item) => item.chat_id)
+          .reduce((acc, cur) => {
+            if (cur && cur.chat_id) {
+              if (!acc[cur.chat_id]) {
+                acc[cur.chat_id] = [];
+              }
+              acc[cur.chat_id].push(cur);
+            }
+            return acc;
+          }, {} as Record<string, BotDiscordHistory[]>);
+
+      const discordResult = Object.keys(discordHistoryGroupByChatId).map(
+        (key) => {
+          return {
+            chat_id: key,
+            human: discordHistoryGroupByChatId[key][0].human,
+            bot: discordHistoryGroupByChatId[key][0].bot,
+            all_messages: getAllMessagesHelper(
+              discordHistoryGroupByChatId[key],
+              "discord"
+            ),
+          };
+        }
+      );
+
+      return reply.status(200).send({
+        message: "Success",
+        data: discordResult,
+      });
+
+    case "whatsapp":
+      const process_whatsapp = await prisma.botIntegration.findFirst({
+        where: {
+          bot_id: id,
+          provider: "whatsapp",
+        },
+      });
+      if (!process_whatsapp) {
+        return reply.status(200).send({
+          message: "Success",
+          data: [],
+        });
+      }
+
+      const whatsappHistory = await prisma.botWhatsappHistory.findMany({
+        where: {
+          identifier: process_whatsapp.identifier,
+        },
+      });
+
+      // group by chat_id
+      const whatsappHistoryGroupByChatId: Record<string, BotWhatsappHistory[]> =
+        whatsappHistory
+          .filter((item) => item.chat_id)
+          .reduce((acc, cur) => {
+            if (cur && cur.chat_id) {
+              if (!acc[cur.chat_id]) {
+                acc[cur.chat_id] = [];
+              }
+              acc[cur.chat_id].push(cur);
+            }
+            return acc;
+          }, {} as Record<string, BotWhatsappHistory[]>);
+
+      const whatsappResult = Object.keys(whatsappHistoryGroupByChatId).map(
+        (key) => {
+          return {
+            chat_id: key,
+            human: whatsappHistoryGroupByChatId[key][0].human,
+            bot: whatsappHistoryGroupByChatId[key][0].bot,
+            all_messages: getAllMessagesHelper(
+              whatsappHistoryGroupByChatId[key],
+              "whatsapp"
+            ),
+          };
+        }
+      );
+
+      return reply.status(200).send({
+        message: "Success",
+        data: whatsappResult,
+      });
+
     default:
       return reply.status(404).send({
         message: "Not Found",
@@ -105,7 +316,7 @@ export const getChatIntergationHistoryByTypeHandler = async (
 
 export const getChatHistoryByChatIdHandler = async (
   request: FastifyRequest<ChatIntergationHistoryByChatIdRequest>,
-  reply: FastifyReply,
+  reply: FastifyReply
 ) => {
   const { id, type, chat_id } = request.params;
   const prisma = request.server.prisma;
diff --git a/server/src/utils/pipleline.js b/server/src/utils/pipleline.js
index 9e9a77c8..ca3d4729 100644
--- a/server/src/utils/pipleline.js
+++ b/server/src/utils/pipleline.js
@@ -1,9 +1,9 @@
 exports.piplelineTransformer = async () => {
   let { pipeline, env } = await import("@xenova/transformers");
   env.useBrowserCache = false;
-  env.allowLocalModels = false;
   if (process.env.NODE_ENV === "production") {
-    env.cacheDir = "./.cache";
+    
+    env.cacheDir = "./uploads/.cache";
   }
   return pipeline;
 };