diff --git a/ai/requirements.txt b/ai/requirements.txt
index fe88a21c..96ee400f 100644
--- a/ai/requirements.txt
+++ b/ai/requirements.txt
@@ -18,4 +18,5 @@ redshift-connector==2.0.917
 mysqlclient==2.2.4
 trino==0.329.0
 snowflake-connector-python==3.12.2
-snowflake-sqlalchemy==1.6.1
\ No newline at end of file
+snowflake-sqlalchemy==1.6.1
+sqlalchemy_monetdb==2.0.0
\ No newline at end of file
diff --git a/apps/api/jupyter-requirements.txt b/apps/api/jupyter-requirements.txt
index cf5f84ff..2fb56903 100644
--- a/apps/api/jupyter-requirements.txt
+++ b/apps/api/jupyter-requirements.txt
@@ -56,4 +56,5 @@ openpyxl==3.1.2
 mysqlclient==2.2.4
 pymongo==4.8.0
 snowflake-connector-python==3.12.2
-snowflake-sqlalchemy==1.6.1
\ No newline at end of file
+snowflake-sqlalchemy==1.6.1
+sqlalchemy_monetdb==2.0.0
\ No newline at end of file
diff --git a/apps/api/src/auth/token.ts b/apps/api/src/auth/token.ts
index e3e14ffd..6a39f4bc 100644
--- a/apps/api/src/auth/token.ts
+++ b/apps/api/src/auth/token.ts
@@ -318,5 +318,9 @@ export const isAuthorizedForDataSource = async (
       const result = await prisma().snowflakeDataSource.findFirst(query)
       return result !== null
     }
+    case 'monetdb': {
+      const result = await prisma().monetDBDataSource.findFirst(query)
+      return result !== null
+    }
   }
 }
diff --git a/apps/api/src/datasources/index.ts b/apps/api/src/datasources/index.ts
index 38f40ee1..06bdfc18 100644
--- a/apps/api/src/datasources/index.ts
+++ b/apps/api/src/datasources/index.ts
@@ -8,6 +8,7 @@ import * as mysql from './mysql.js'
 import * as trino from './trino.js'
 import * as sqlserver from './sqlserver.js'
 import * as snowflake from './snowflake.js'
+import * as monetdb from "./monetdb.js"
 import { DataSourceConnectionError } from '@briefer/types'
 
 export async function ping(ds: DataSource): Promise<DataSource> {
@@ -40,6 +41,9 @@ export async function ping(ds: DataSource): Promise<DataSource> {
     case 'snowflake':
       result = await snowflake.ping(ds.data)
       break
+    case "monetdb":
+      result = await monetdb.ping(ds.data)
+      break
   }
 
   return result
@@ -78,5 +82,7 @@ export async function updateConnStatus(
       return trino.updateConnStatus(ds.data, status)
     case 'snowflake':
       return snowflake.updateConnStatus(ds.data, status)
+    case "monetdb":
+      return monetdb.updateConnStatus(ds.data, status)
   }
 }
diff --git a/apps/api/src/datasources/monetdb.ts b/apps/api/src/datasources/monetdb.ts
new file mode 100644
index 00000000..b6e746ee
--- /dev/null
+++ b/apps/api/src/datasources/monetdb.ts
@@ -0,0 +1,46 @@
+import { config } from '../config/index.js'
+import prisma, { DataSource, MonetDBDataSource } from '@briefer/database'
+import { DataSourceStatus } from './index.js'
+import { pingMonetDb } from '../python/query/monetdb.js'
+
+export async function ping(ds: MonetDBDataSource): Promise<DataSource> {
+  const lastConnection = new Date()
+  const err = await pingMonetDb(ds, config().DATASOURCES_ENCRYPTION_KEY)
+
+  if (!err) {
+    return updateConnStatus(ds, {
+      connStatus: 'online',
+      lastConnection,
+    })
+  }
+
+  return updateConnStatus(ds, { connStatus: 'offline', connError: err })
+}
+
+export async function updateConnStatus(
+  ds: MonetDBDataSource,
+  status: DataSourceStatus
+): Promise<DataSource> {
+  const newDs = await prisma().monetDBDataSource.update({
+    where: { id: ds.id },
+    data: {
+      connStatus: status.connStatus,
+      lastConnection:
+        status.connStatus === 'online' ? status.lastConnection : undefined,
+      connError:
+        status.connStatus === 'offline'
+          ? JSON.stringify(status.connError)
+          : undefined,
+    },
+  })
+
+  return {
+    type: "monetdb",
+    data: {
+      ...ds,
+      connStatus: newDs.connStatus,
+      lastConnection: newDs.lastConnection?.toISOString() ?? null,
+      connError: newDs.connError,
+    },
+  }
+}
diff --git a/apps/api/src/datasources/structure.ts b/apps/api/src/datasources/structure.ts
index f4736695..bb6316cf 100644
--- a/apps/api/src/datasources/structure.ts
+++ b/apps/api/src/datasources/structure.ts
@@ -23,6 +23,7 @@ import { getOracleSchema } from '../python/query/oracle.js'
 import { getBigQuerySchema } from '../python/query/bigquery.js'
 import { getTrinoSchema } from '../python/query/trino.js'
 import { getSnowflakeSchema } from '../python/query/snowflake.js'
+import { getMonetDBSchema } from '../python/query/monetdb.js'
 import { getAthenaSchema } from './athena.js'
 import { getMySQLSchema } from './mysql.js'
 import { z } from 'zod'
@@ -127,6 +128,14 @@ async function getFromCache(
         })
       ).structure
       break
+    case "monetdb":
+      encrypted = (
+        await prisma().monetDBDataSource.findUniqueOrThrow({
+          where: { id: dataSourceId },
+          select: { structure: true },
+        })
+      ).structure
+      break
   }
 
   if (encrypted === null) {
@@ -307,6 +316,13 @@ async function _refreshDataSourceStructure(
           onTable
         )
         break
+      case "monetdb":
+        finalStructure = await getMonetDBSchema(
+          dataSource.config.data,
+          config().DATASOURCES_ENCRYPTION_KEY,
+          onTable
+        )
+        break
     }
 
     await updateQueue.onIdle()
@@ -461,6 +477,12 @@ async function persist(ds: APIDataSource): Promise<APIDataSource> {
           data: { structure },
         })
         return ds
+      case "monetdb":
+        await prisma().monetDBDataSource.update({
+          where: { id: ds.config.data.id },
+          data: { structure },
+        })
+        return ds
     }
   })()
 }
diff --git a/apps/api/src/python/query/index.ts b/apps/api/src/python/query/index.ts
index a4e16b6c..d66e2e50 100644
--- a/apps/api/src/python/query/index.ts
+++ b/apps/api/src/python/query/index.ts
@@ -21,6 +21,7 @@ import { makeSnowflakeQuery } from './snowflake.js'
 import { updateConnStatus } from '../../datasources/index.js'
 import { getJupyterManager } from '../../jupyter/index.js'
 import { makeSQLServerQuery } from './sqlserver.js'
+import { makeMonetDBQuery } from './monetdb.js'
 
 export async function makeSQLQuery(
   workspaceId: string,
@@ -144,6 +145,18 @@ export async function makeSQLQuery(
         onProgress
       )
       break
+    case "monetdb":
+      result = await makeMonetDBQuery(
+        workspaceId,
+        sessionId,
+        queryId,
+        dataframeName,
+        datasource.data,
+        encryptionKey,
+        sql,
+        onProgress
+      )
+      break
   }
 
   result[0].then(async (r) => {
diff --git a/apps/api/src/python/query/monetdb.ts b/apps/api/src/python/query/monetdb.ts
new file mode 100644
index 00000000..f9690fc2
--- /dev/null
+++ b/apps/api/src/python/query/monetdb.ts
@@ -0,0 +1,62 @@
+import { v4 as uuidv4 } from 'uuid'
+import {
+  MonetDBDataSource,
+  getDatabaseURL,
+} from '@briefer/database'
+import {
+  DataSourceStructure,
+  RunQueryResult,
+  SuccessRunQueryResult,
+} from '@briefer/types'
+import {
+  getSQLAlchemySchema,
+  makeSQLAlchemyQuery,
+  pingSQLAlchemy,
+} from './sqlalchemy.js'
+import { OnTable } from '../../datasources/structure.js'
+
+export async function makeMonetDBQuery(
+  workspaceId: string,
+  sessionId: string,
+  queryId: string,
+  dataframeName: string,
+  datasource: MonetDBDataSource,
+  encryptionKey: string,
+  sql: string,
+  onProgress: (result: SuccessRunQueryResult) => void
+): Promise<[Promise<RunQueryResult>, () => Promise<void>]> {
+  const databaseUrl = await getDatabaseURL(
+    { type: "monetdb", data: datasource },
+    encryptionKey
+  )
+
+  const jobId = uuidv4()
+  const query = `${sql}  -- Briefer jobId: ${jobId}`
+
+  return makeSQLAlchemyQuery(
+    workspaceId,
+    sessionId,
+    dataframeName,
+    databaseUrl,
+    "monetdb",
+    jobId,
+    query,
+    queryId,
+    onProgress
+  )
+}
+
+export function pingMonetDb(
+  ds: MonetDBDataSource,
+  encryptionKey: string
+): Promise<null | Error> {
+  return pingSQLAlchemy({ type: "monetdb", data: ds }, encryptionKey, null)
+}
+
+export function getMonetDBSchema(
+  ds: MonetDBDataSource,
+  encryptionKey: string,
+  onTable: OnTable
+): Promise<DataSourceStructure> {
+  return getSQLAlchemySchema({ type: "monetdb", data: ds }, encryptionKey, null, onTable)
+}
diff --git a/apps/api/src/python/query/sqlalchemy.ts b/apps/api/src/python/query/sqlalchemy.ts
index 69dccacb..5c1919db 100644
--- a/apps/api/src/python/query/sqlalchemy.ts
+++ b/apps/api/src/python/query/sqlalchemy.ts
@@ -24,7 +24,8 @@ export async function makeSQLAlchemyQuery(
     | 'psql'
     | 'redshift'
     | 'trino'
-    | 'snowflake',
+    | 'snowflake'
+    | "monetdb",
   jobId: string,
   query: string,
   queryId: string,
diff --git a/apps/api/src/python/writeback/index.ts b/apps/api/src/python/writeback/index.ts
index 34a38bb0..222819af 100644
--- a/apps/api/src/python/writeback/index.ts
+++ b/apps/api/src/python/writeback/index.ts
@@ -54,6 +54,7 @@ export async function writeback(
     case 'oracle':
     case 'athena':
     case 'snowflake':
+    case "monetdb":
     case 'trino':
       throw new Error(`${datasource.type} writeback not implemented`)
   }
diff --git a/apps/api/src/v1/workspaces/workspace/data-sources/data-source.ts b/apps/api/src/v1/workspaces/workspace/data-sources/data-source.ts
index db4bab5d..b1739599 100644
--- a/apps/api/src/v1/workspaces/workspace/data-sources/data-source.ts
+++ b/apps/api/src/v1/workspaces/workspace/data-sources/data-source.ts
@@ -29,6 +29,9 @@ import {
   getSnowflakeDataSource,
   updateSnowflakeDataSource,
   deleteSnowflakeDataSource,
+  getMonetDbDataSource,
+  updateMonedDbDataSource,
+  deleteMonetDbDataSource
 } from '@briefer/database'
 import { z } from 'zod'
 import { getParam } from '../../../../utils/express.js'
@@ -42,6 +45,7 @@ import * as mysql from '../../../../datasources/mysql.js'
 import * as sqlserver from '../../../../datasources/sqlserver.js'
 import * as trino from '../../../../datasources/trino.js'
 import * as snowflake from '../../../../datasources/snowflake.js'
+import * as monetDb from "../../../../datasources/monetdb.js"
 import { ping } from '../../../../datasources/index.js'
 import { fetchDataSourceStructure } from '../../../../datasources/structure.js'
 import {
@@ -148,6 +152,21 @@ const dataSourceRouter = (socketServer: IOServer) => {
         notes: z.string(),
       }),
     }),
+    z.object({
+      type: z.literal('monetdb'),
+      data: z.object({
+        id: z.string().min(1),
+        name: z.string().min(1),
+        host: z.string().min(1),
+        port: z.string().min(1),
+        database: z.string().min(1),
+        username: z.string().min(1),
+        password: z.string(),
+        notes: z.string(),
+        readOnly: z.boolean(),
+        cert: z.string().optional(),
+      }),
+    }),
   ])
 
   router.put('/', async (req, res) => {
@@ -171,6 +190,7 @@ const dataSourceRouter = (socketServer: IOServer) => {
         getSQLServerDataSource(workspaceId, dataSourceId),
         getTrinoDataSource(workspaceId, dataSourceId),
         getSnowflakeDataSource(workspaceId, dataSourceId),
+        getMonetDbDataSource(workspaceId, dataSourceId),
       ])
     ).find((e) => e !== null)
     if (!existingDb) {
@@ -325,6 +345,20 @@ const dataSourceRouter = (socketServer: IOServer) => {
         await snowflake.ping(snowflakeDs)
         break
       }
+      case "monetdb": {
+        const monetDbDs = await updateMonedDbDataSource(
+          {
+            ...data.data,
+            id: dataSourceId,
+            password:
+              data.data.password === '' ? undefined : data.data.password,
+          },
+          config().DATASOURCES_ENCRYPTION_KEY
+        )
+
+        await monetDb.ping(monetDbDs)
+        break
+      }
     }
 
     const ds = await getDatasource(workspaceId, dataSourceId, data.type)
@@ -473,6 +507,19 @@ const dataSourceRouter = (socketServer: IOServer) => {
         }
       }
 
+      const targetMonetDb = await recoverFromNotFound(
+        deleteMonetDbDataSource(workspaceId, targetId)
+      )
+      if(targetMonetDb) {
+        return {
+          status: 200,
+          payload: {
+            type: 'monetdb',
+            data: targetMonetDb,
+          },
+        }
+      }
+
       return { status: 404 }
     }
 
@@ -497,6 +544,7 @@ const dataSourceRouter = (socketServer: IOServer) => {
       z.literal('trino'),
       z.literal('sqlserver'),
       z.literal('snowflake'),
+      z.literal("monetdb"),
     ]),
   })
   router.post('/ping', async (req, res) => {
@@ -520,6 +568,7 @@ const dataSourceRouter = (socketServer: IOServer) => {
         return
       }
 
+
       const dsConfig = await ping(dataSource)
 
       await broadcastDataSource(socketServer, {
diff --git a/apps/api/src/v1/workspaces/workspace/data-sources/index.ts b/apps/api/src/v1/workspaces/workspace/data-sources/index.ts
index 3389ab15..81d9fbbb 100644
--- a/apps/api/src/v1/workspaces/workspace/data-sources/index.ts
+++ b/apps/api/src/v1/workspaces/workspace/data-sources/index.ts
@@ -11,6 +11,7 @@ import {
   createTrinoDataSource,
   createSQLServerDataSource,
   createSnowflakeDataSource,
+  createMonetDbDataSource,
 } from '@briefer/database'
 import { z } from 'zod'
 import { getParam } from '../../../../utils/express.js'
@@ -112,6 +113,20 @@ const dataSourcePayload = z.union([
       notes: z.string(),
     }),
   }),
+  z.object({
+    type: z.literal('monetdb'),
+    data: z.object({
+      name: z.string().min(1),
+      host: z.string().min(1),
+      port: z.string().min(1),
+      database: z.string().min(1),
+      username: z.string().min(1),
+      password: z.string().min(1),
+      notes: z.string(),
+      readOnly: z.boolean(),
+      cert: z.string().optional(),
+    }),
+  }),
 ])
 
 export type DataSourcePayload = z.infer<typeof dataSourcePayload>
@@ -287,6 +302,22 @@ const dataSourcesRouter = (socketServer: IOServer) => {
             dsRes = { type: 'snowflake', data: ds }
             break
           }
+          case "monetdb": {
+            const payload = {
+              ...data.data,
+              workspaceId,
+              cert: data.data.cert ?? null,
+              connStatus: 'offline' as const,
+              connError: JSON.stringify(neverPingedError),
+              lastConnection: null,
+            }
+            const ds = await createMonetDbDataSource(
+              payload,
+              config().DATASOURCES_ENCRYPTION_KEY
+            )
+            dsRes = { type: 'monetdb', data: ds }
+            break
+          }
         }
 
         return dsRes
@@ -301,6 +332,7 @@ const dataSourcesRouter = (socketServer: IOServer) => {
           case 'athena':
           case 'sqlserver':
           case 'snowflake':
+          case "monetdb":
           case 'trino':
             return null
           case 'oracle': {
@@ -373,6 +405,7 @@ const dataSourcesRouter = (socketServer: IOServer) => {
         getDatasource(workspaceId, dataSourceId, 'sqlserver'),
         getDatasource(workspaceId, dataSourceId, 'trino'),
         getDatasource(workspaceId, dataSourceId, 'snowflake'),
+        getDatasource(workspaceId, dataSourceId, "monetdb")
       ])
     ).find((e) => e !== null)
 
diff --git a/apps/web/public/icons/monetdb.png b/apps/web/public/icons/monetdb.png
new file mode 100644
index 00000000..8ea1d10f
Binary files /dev/null and b/apps/web/public/icons/monetdb.png differ
diff --git a/apps/web/src/components/DataSourceIcons.tsx b/apps/web/src/components/DataSourceIcons.tsx
index 64cd79dd..fef99826 100644
--- a/apps/web/src/components/DataSourceIcons.tsx
+++ b/apps/web/src/components/DataSourceIcons.tsx
@@ -62,6 +62,11 @@ export const DataSourceIcons = ({
         name="Snowflake"
         href={`/workspaces/${workspaceId}/data-sources/new/snowflake`}
       />
+      <DataSourceBlock
+        icon="/icons/monetdb.png"
+        name="MonetDB"
+        href={`/workspaces/${workspaceId}/data-sources/new/monetdb`}
+      />
       <button
         onClick={onCSV}
         className="h-24 w-24 py-3 px-6 border border-gray-200 rounded-md flex flex-col items-center justify-between bg-gray-50 hover:bg-ceramic-50 hover:border-gray-300"
diff --git a/apps/web/src/components/DataSourcesList.tsx b/apps/web/src/components/DataSourcesList.tsx
index 4371b62f..22a532a6 100644
--- a/apps/web/src/components/DataSourcesList.tsx
+++ b/apps/web/src/components/DataSourcesList.tsx
@@ -27,6 +27,8 @@ export const dataSourcePrettyName = (t: DataSourceType): string => {
       return 'Trino'
     case 'snowflake':
       return 'Snowflake'
+    case 'monetdb':
+      return 'MonetDB'
   }
 }
 
@@ -50,6 +52,8 @@ export const databaseImages = (t: DataSourceType): string => {
       return '/icons/trino.png'
     case 'snowflake':
       return '/icons/snowflake.png'
+    case 'monetdb':
+      return '/icons/monetdb.png'
   }
 }
 
@@ -74,6 +78,8 @@ const databaseUrl = (ds: DataSource): string => {
         return 'trino://demodb'
       case 'snowflake':
         return 'snowflake://demodb'
+      case 'monetdb':
+        return 'monetdb://demodb'
     }
   } else {
     switch (ds.type) {
@@ -98,6 +104,8 @@ const databaseUrl = (ds: DataSource): string => {
         )
       case 'snowflake':
         return `snowflake://${ds.data.account}/${ds.data.database}?warehouse=${ds.data.warehouse}`
+      case "monetdb":
+        return `monetdb://${ds.data.host}:${ds.data.port}/${ds.data.database}`
     }
   }
 }
@@ -128,15 +136,15 @@ function LastConnection(props: LastConnectionProps) {
   const lastConnText = props.dataSource.data.isDemo
     ? 'just now'
     : props.dataSource.data.lastConnection === null
-    ? 'never'
-    : differenceInSeconds(
-        new Date(),
-        new Date(props.dataSource.data.lastConnection)
-      ) < 30
-    ? 'just now'
-    : formatDistanceToNow(new Date(props.dataSource.data.lastConnection), {
-        addSuffix: true,
-      })
+      ? 'never'
+      : differenceInSeconds(
+            new Date(),
+            new Date(props.dataSource.data.lastConnection)
+          ) < 30
+        ? 'just now'
+        : formatDistanceToNow(new Date(props.dataSource.data.lastConnection), {
+            addSuffix: true,
+          })
 
   const [statusBallColor, statusBallRippleColor] = useMemo(() => {
     if (props.dataSource.data.isDemo) {
diff --git a/apps/web/src/components/forms/monetdb.tsx b/apps/web/src/components/forms/monetdb.tsx
new file mode 100644
index 00000000..80c0bf83
--- /dev/null
+++ b/apps/web/src/components/forms/monetdb.tsx
@@ -0,0 +1,303 @@
+import type { MonetDBDataSource } from '@briefer/database'
+import Link from 'next/link'
+import { useEffect } from 'react'
+import { useForm } from 'react-hook-form'
+
+import FormError from './formError'
+import FileUploadInput from './FileUploadInput'
+import { readFile } from '@/utils/file'
+import { GATEWAY_IP } from '@/utils/info'
+import Spin from '../Spin'
+
+export type MonetDbDataSourceInput = MonetDBDataSource & {
+  password: string
+  cert?: string
+}
+
+type MonetDbDataSourceFormValues = Omit<
+MonetDbDataSourceInput,
+  'cert'
+> & {
+  password: string
+  cert: File
+}
+
+type MonetDbFormProps = {
+  onSubmit: (values: MonetDbDataSourceInput) => Promise<void>
+  monetDbDataSource?: MonetDBDataSource | null
+  workspaceId: string
+}
+
+export default function MonetDBForm({
+  monetDbDataSource,
+  onSubmit,
+  workspaceId,
+}: MonetDbFormProps) {
+  const isEditing = Boolean(monetDbDataSource)
+
+  const { register, handleSubmit, formState, reset, control } =
+    useForm<MonetDbDataSourceFormValues>({
+      mode: 'onChange',
+      defaultValues: { readOnly: true },
+    })
+
+  useEffect(() => {
+    if (monetDbDataSource) {
+      reset(monetDbDataSource)
+    }
+  }, [monetDbDataSource, reset])
+
+  const onSubmitHandler = handleSubmit(async (data) => {
+    const certFile = data.cert
+    let certContent = undefined as string | undefined
+    if (certFile) {
+      certContent = await readFile(certFile, 'hex')
+    }
+
+    await onSubmit({
+      ...data,
+      cert: certContent,
+    })
+  })
+
+  return (
+    <form className="px-4 sm:p-6 lg:p-12" onSubmit={onSubmitHandler} noValidate>
+      <div className="space-y-12">
+        <div className="border-b border-gray-900/10 pb-8">
+          <h2 className="text-lg font-semibold leading-7 text-gray-900">
+            {monetDbDataSource ? 'Edit' : 'New'} MonetDb data source
+          </h2>
+          <p className="mt-1 text-sm leading-6 text-gray-500">
+            {monetDbDataSource ? 'Edit' : 'Add'} a MonetDb database for
+            Briefer to pull data from. Our fixed IP address is{' '}
+            <code className="bg-gray-100 px-1 py-0.5 rounded-md text-red-500 text-xs">
+              {GATEWAY_IP()}
+            </code>
+            .
+          </p>
+
+          <div className="mt-10 grid grid-cols-1 gap-x-6 gap-y-2 sm:grid-cols-10">
+            <div className="col-span-full">
+              <label
+                htmlFor="name"
+                className="block text-sm font-medium leading-6 text-gray-900"
+              >
+                Display name
+              </label>
+              <div className="mt-2">
+                <input
+                  {...register('name', {
+                    required: {
+                      value: true,
+                      message: 'Display name is required.',
+                    },
+                  })}
+                  type="text"
+                  name="name"
+                  placeholder="My MonetDb database"
+                  required
+                  className="block w-full rounded-md border-0 py-3 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-ceramic-200/70 sm:text-md sm:leading-6"
+                />
+                <FormError msg={formState.errors.name?.message} />
+              </div>
+            </div>
+
+            <div className="col-span-7">
+              <label
+                htmlFor="host"
+                className="block text-sm font-medium leading-6 text-gray-900"
+              >
+                Host
+              </label>
+              <div className="mt-2">
+                <input
+                  {...register('host', {
+                    required: { value: true, message: 'Host is required.' },
+                  })}
+                  type="text"
+                  name="host"
+                  placeholder="example.com"
+                  required
+                  className="block w-full rounded-md border-0 py-3 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-ceramic-200/70 sm:text-md sm:leading-6"
+                />
+                <FormError msg={formState.errors.host?.message} />
+              </div>
+            </div>
+
+            <div className="col-span-3">
+              <label
+                htmlFor="port"
+                className="block text-sm font-medium leading-6 text-gray-900"
+              >
+                Port
+              </label>
+              <div className="mt-2">
+                <input
+                  {...register('port', {
+                    required: { value: true, message: 'Port is required.' },
+                    validate: (v: any) => {
+                      v = parseInt(v)
+                      if (isNaN(v)) return 'Port must be a number.'
+                      return true
+                    },
+                  })}
+                  type="number"
+                  name="port"
+                  placeholder="50000"
+                  required
+                  className="block w-full rounded-md border-0 py-3 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-ceramic-200/70 sm:text-md sm:leading-6"
+                />
+                <FormError msg={formState.errors.port?.message} />
+              </div>
+            </div>
+
+            <div className="col-span-4">
+              <label
+                htmlFor="database"
+                className="block text-sm font-medium leading-6 text-gray-900"
+              >
+                Database name
+              </label>
+              <div className="mt-2">
+                <input
+                  {...register('database', {
+                    required: {
+                      value: true,
+                      message: 'Database is required.',
+                    },
+                  })}
+                  type="text"
+                  name="database"
+                  placeholder="db"
+                  required
+                  className="block w-full rounded-md border-0 py-3 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-ceramic-200/70 sm:text-md sm:leading-6"
+                />
+                <FormError msg={formState.errors.database?.message} />
+              </div>
+            </div>
+
+            <div className="col-span-3">
+              <label
+                htmlFor="username"
+                className="block text-sm font-medium leading-6 text-gray-900"
+              >
+                Username
+              </label>
+              <div className="mt-2">
+                <input
+                  {...register('username', {
+                    required: {
+                      value: true,
+                      message: 'Username is required.',
+                    },
+                  })}
+                  type="text"
+                  name="username"
+                  placeholder="monetdb"
+                  required
+                  className="block w-full rounded-md border-0 py-3 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-ceramic-200/70 sm:text-md sm:leading-6"
+                />
+                <FormError msg={formState.errors.username?.message} />
+              </div>
+            </div>
+
+            <div className="col-span-3">
+              <label
+                htmlFor="password"
+                className="block text-sm font-medium leading-6 text-gray-900"
+              >
+                Password
+              </label>
+              <div className="mt-2">
+                <input
+                  {...register('password', {
+                    required: {
+                      value: !isEditing,
+                      message: 'Password is required.',
+                    },
+                  })}
+                  type="password"
+                  name="password"
+                  required={!isEditing}
+                  className="block w-full rounded-md border-0 py-3 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-ceramic-200/70 sm:text-md sm:leading-6"
+                />
+                {isEditing && !Boolean(formState.errors.password) && (
+                  <span className="block text-sm text-gray-900 empty:before:content-['\200b'] pt-1 pb-1">
+                    Leave empty to keep previous password
+                  </span>
+                )}
+                <FormError msg={formState.errors.password?.message} />
+              </div>
+            </div>
+            <div className="col-span-full">
+              <label
+                htmlFor="cert"
+                className="block text-sm font-medium leading-6 text-gray-900"
+              >
+                SSL Cert
+              </label>
+              <FileUploadInput
+                label={
+                  isEditing
+                    ? 'Upload a new SSL cert, leave empty if not needed'
+                    : 'Upload a SSL cert, leave empty if not needed'
+                }
+                subLabel={
+                  isEditing
+                    ? 'or drag and drop, leave empty to keep previous cert'
+                    : 'or drag and drop'
+                }
+                control={control}
+                {...register('cert')}
+              />
+            </div>
+
+            <div className="col-span-full">
+              <label
+                htmlFor="notes"
+                className="block text-sm font-medium leading-6 text-gray-900"
+              >
+                Notes
+              </label>
+              <div className="mt-2">
+                <textarea
+                  {...register('notes', { required: false })}
+                  name="notes"
+                  rows={3}
+                  className="block w-full rounded-md border-0 py-3 text-gray-900 shadow-sm ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-ceramic-200/70 sm:text-md sm:leading-6"
+                  defaultValue={''}
+                />
+              </div>
+              <p className="mt-3 text-sm leading-6 text-gray-600">
+                Add any notes about this database you may want others to be
+                aware of.
+              </p>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div className="mt-6 flex items-center justify-end gap-x-4">
+        <Link
+          href={`/workspaces/${workspaceId}/data-sources`}
+          className="text-sm font-semibold leading-6 text-gray-600 border border-gray-400 px-6 py-1.5 rounded-sm shadow-sm hover:bg-gray-50"
+        >
+          Cancel
+        </Link>
+        <button
+          type="submit"
+          className="flex items-center justify-center gap-x-2 rounded-sm shadow-sm bg-primary-200 px-6 py-2.5 text-sm font-semibold hover:bg-primary-300 border-stone-950 disabled:bg-gray-300 disabled:cursor-not-allowed"
+          disabled={formState.isSubmitting}
+        >
+          {formState.isSubmitting ? (
+            <>
+              <Spin /> Validating
+            </>
+          ) : (
+            'Save'
+          )}
+        </button>
+      </div>
+    </form>
+  )
+}
diff --git a/apps/web/src/hooks/useDatasource.ts b/apps/web/src/hooks/useDatasource.ts
index 06f3312c..f817a469 100644
--- a/apps/web/src/hooks/useDatasource.ts
+++ b/apps/web/src/hooks/useDatasource.ts
@@ -96,7 +96,9 @@ export const useNewDataSource = (workspaceId: string) => {
         | 'mysql'
         | 'trino'
         | 'sqlserver'
+        | 'monetdb'
         | 'snowflake'
+        | 'monetdb'
     ): Promise<DataSource> => {
       if (!workspaceId) {
         throw new Error('Missing workspaceId')
diff --git a/apps/web/src/pages/workspaces/[workspaceId]/data-sources/edit/[dataSourceId].tsx b/apps/web/src/pages/workspaces/[workspaceId]/data-sources/edit/[dataSourceId].tsx
index 0dac125f..f6e99f5b 100644
--- a/apps/web/src/pages/workspaces/[workspaceId]/data-sources/edit/[dataSourceId].tsx
+++ b/apps/web/src/pages/workspaces/[workspaceId]/data-sources/edit/[dataSourceId].tsx
@@ -26,6 +26,7 @@ import SQLServerForm from '@/components/forms/sqlserver'
 import SnowflakeForm, {
   SnowflakeDataSourceInput,
 } from '@/components/forms/snowflake'
+import MonetDBForm, { MonetDbDataSourceInput } from '@/components/forms/monetdb'
 
 export default function EditDataSourcePostgresSQLPage() {
   const router = useRouter()
@@ -45,6 +46,7 @@ export default function EditDataSourcePostgresSQLPage() {
         | MySQLDataSourceInput
         | TrinoDataSourceInput
         | SnowflakeDataSourceInput
+        | MonetDbDataSourceInput
     ) => {
       if (!data) {
         return
@@ -144,6 +146,12 @@ export default function EditDataSourcePostgresSQLPage() {
             onSubmit={onSubmit}
             snowflakeDataSource={data.config.data}
           />
+        ) : data && data.config.type === 'monetdb' ? (
+          <MonetDBForm
+            workspaceId={workspaceId}
+            onSubmit={onSubmit}
+            monetDbDataSource={data.config.data}
+          />
         ) : null}
       </div>
     </Layout>
diff --git a/apps/web/src/pages/workspaces/[workspaceId]/data-sources/new/index.tsx b/apps/web/src/pages/workspaces/[workspaceId]/data-sources/new/index.tsx
index 566a10cf..95a1e989 100644
--- a/apps/web/src/pages/workspaces/[workspaceId]/data-sources/new/index.tsx
+++ b/apps/web/src/pages/workspaces/[workspaceId]/data-sources/new/index.tsx
@@ -34,7 +34,7 @@ const DataSourceBlock = ({ name, icon, href }: DataSourceBlockProps) => {
       href={href}
       className="py-5 px-6 w-36 h-36 border border-gray-200 rounded-md flex flex-col items-center justify-between bg-gray-50 hover:bg-ceramic-50 hover:border-gray-300"
     >
-      <img src={icon} alt="" className="h-16 w-16" />
+      <img src={icon} alt="" className="h-16 w-16 object-contain" />
       <span className="text-md">{name}</span>
     </Link>
   )
@@ -98,6 +98,11 @@ export default function DataSourcesPage() {
               name="Trino"
               href={`/workspaces/${workspaceId}/data-sources/new/trino`}
             />
+            <DataSourceBlock
+              icon="/icons/monetdb.png"
+              name="MonetDB"
+              href={`/workspaces/${workspaceId}/data-sources/new/monetdb`}
+            />
             <DataSourceBlock
               icon="/icons/snowflake.png"
               name="Snowflake"
diff --git a/apps/web/src/pages/workspaces/[workspaceId]/data-sources/new/monetdb.tsx b/apps/web/src/pages/workspaces/[workspaceId]/data-sources/new/monetdb.tsx
new file mode 100644
index 00000000..79b06a9a
--- /dev/null
+++ b/apps/web/src/pages/workspaces/[workspaceId]/data-sources/new/monetdb.tsx
@@ -0,0 +1,60 @@
+import Layout from '@/components/Layout'
+import { useRouter } from 'next/router'
+import {
+  CircleStackIcon,
+  Cog8ToothIcon,
+  PlusCircleIcon,
+} from '@heroicons/react/24/outline'
+import { useCallback } from 'react'
+import { useNewDataSource } from '@/hooks/useDatasource'
+import { useStringQuery } from '@/hooks/useQueryArgs'
+import MonetDBForm, { MonetDbDataSourceInput } from '@/components/forms/monetdb'
+
+const pagePath = (workspaceId: string) => [
+  { name: 'Configurations', icon: Cog8ToothIcon, href: '#', current: false },
+  {
+    name: 'Data sources',
+    icon: CircleStackIcon,
+    href: `/workspaces/${workspaceId}/data-sources`,
+    current: false,
+  },
+  {
+    name: 'Add MonetDB data source',
+    icon: PlusCircleIcon,
+    href: '#',
+    current: true,
+  },
+]
+
+export default function NewDataSourceMonetDBPage() {
+  const router = useRouter()
+  const workspaceId = useStringQuery('workspaceId')
+
+  const newDataSource = useNewDataSource(workspaceId)
+
+  const onSubmit = useCallback(
+    async (data: MonetDbDataSourceInput) => {
+      try {
+        const ds = await newDataSource(data, 'monetdb')
+        if (ds.data.connStatus === 'offline') {
+          router.push(
+            `/workspaces/${workspaceId}/data-sources?offline=${ds.data.id}`
+          )
+        } else {
+          router.push(`/workspaces/${workspaceId}/data-sources`)
+        }
+      } catch {
+        alert('Something went wrong')
+      }
+    },
+    [workspaceId]
+  )
+
+  return (
+    <Layout pagePath={pagePath(workspaceId)} hideOnboarding>
+      <div className="w-full overflow-scroll">
+        <MonetDBForm workspaceId={workspaceId} onSubmit={onSubmit} />
+      </div>
+    </Layout>
+  )
+}
diff --git a/apps/web/src/pages/workspaces/[workspaceId]/environments/current/index.tsx b/apps/web/src/pages/workspaces/[workspaceId]/environments/current/index.tsx
index 13111134..0eb6ce34 100644
--- a/apps/web/src/pages/workspaces/[workspaceId]/environments/current/index.tsx
+++ b/apps/web/src/pages/workspaces/[workspaceId]/environments/current/index.tsx
@@ -215,4 +215,5 @@ openpyxl==3.1.2
 mysqlclient==2.2.4
 pymongo==4.8.0
 snowflake-connector-python==3.12.2
-snowflake-sqlalchemy==1.6.1`
+snowflake-sqlalchemy==1.6.1
+sqlalchemy_monetdb==2.0.0`
\ No newline at end of file
diff --git a/packages/database/prisma/migrations/20241010071355_introduce_monetdb_datasource/migration.sql b/packages/database/prisma/migrations/20241010071355_introduce_monetdb_datasource/migration.sql
new file mode 100644
index 00000000..4ff28e5f
--- /dev/null
+++ b/packages/database/prisma/migrations/20241010071355_introduce_monetdb_datasource/migration.sql
@@ -0,0 +1,26 @@
+-- CreateTable
+CREATE TABLE "MonetDBDataSource" (
+    "id" UUID NOT NULL DEFAULT gen_random_uuid(),
+    "name" TEXT NOT NULL,
+    "host" TEXT NOT NULL,
+    "port" TEXT NOT NULL,
+    "database" TEXT NOT NULL,
+    "username" TEXT NOT NULL,
+    "password" TEXT NOT NULL,
+    "notes" TEXT NOT NULL,
+    "readOnly" BOOLEAN NOT NULL DEFAULT true,
+    "cert" TEXT,
+    "structure" TEXT,
+    "isDemo" BOOLEAN NOT NULL DEFAULT false,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "connStatus" "ConnStatus" NOT NULL DEFAULT 'online',
+    "connError" TEXT,
+    "lastConnection" TIMESTAMP(3),
+    "workspaceId" UUID NOT NULL,
+
+    CONSTRAINT "MonetDBDataSource_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "MonetDBDataSource" ADD CONSTRAINT "MonetDBDataSource_workspaceId_fkey" FOREIGN KEY ("workspaceId") REFERENCES "Workspace"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/packages/database/prisma/schema.prisma b/packages/database/prisma/schema.prisma
index 60b11d3d..69db439f 100644
--- a/packages/database/prisma/schema.prisma
+++ b/packages/database/prisma/schema.prisma
@@ -281,6 +281,29 @@ model TrinoDataSource {
   workspace   Workspace @relation(fields: [workspaceId], references: [id], onDelete: Cascade)
 }
 
+model MonetDBDataSource {
+  id             String     @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
+  name           String
+  host           String
+  port           String
+  database       String
+  username       String
+  password       String
+  notes          String
+  readOnly       Boolean    @default(true)
+  cert           String?
+  structure      String?
+  isDemo         Boolean    @default(false)
+  createdAt      DateTime   @default(now())
+  updatedAt      DateTime   @default(now()) @updatedAt
+  connStatus     ConnStatus @default(online)
+  connError      String?
+  lastConnection DateTime?
+
+  workspaceId String    @db.Uuid
+  workspace   Workspace @relation(fields: [workspaceId], references: [id], onDelete: Cascade)
+}
+
 model User {
   id             String   @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
   name           String   @default("")
@@ -391,6 +414,7 @@ model Workspace {
   mySQLDataSources     MySQLDataSource[]
   sqlServerDataSources SQLServerDataSource[]
   trinoDataSources     TrinoDataSource[]
+  monetDBDataSources   MonetDBDataSource[]
   snowflakeDataSources SnowflakeDataSource[]
   environmentVariables EnvironmentVariable[]
 }
diff --git a/packages/database/src/datasources/index.ts b/packages/database/src/datasources/index.ts
index ff05fabb..0537e47e 100644
--- a/packages/database/src/datasources/index.ts
+++ b/packages/database/src/datasources/index.ts
@@ -9,6 +9,7 @@ import * as oracle from './oracle.js'
 import * as mysql from './mysql.js'
 import * as trino from './trino.js'
 import * as sqlserver from './sqlserver.js'
+import * as monetdb from './monetdb.js'
 import * as snowflake from './snowflake.js'
 import { DataSourceStructureStateV2 } from '@briefer/types'
 import { z } from 'zod'
@@ -23,6 +24,7 @@ export * from './sqlserver.js'
 export * from './crypto.js'
 export * from './trino.js'
 export * from './snowflake.js'
+export * from "./monetdb.js"
 
 export type BigQueryDataSource = bq.BigQueryDataSource
 export type PostgreSQLDataSource = psql.PostgreSQLDataSource
@@ -33,6 +35,7 @@ export type MySQLDataSource = mysql.MySQLDataSource
 export type TrinoDataSource = trino.TrinoDataSource
 export type SQLServerDataSource = sqlserver.SQLServerDataSource
 export type SnowflakeDataSource = snowflake.SnowflakeDataSource
+export type MonetDBDataSource = monetdb.MonetDBDataSource
 
 export type DataSource =
   | { type: 'psql'; data: PostgreSQLDataSource }
@@ -43,6 +46,7 @@ export type DataSource =
   | { type: 'mysql'; data: MySQLDataSource }
   | { type: 'trino'; data: TrinoDataSource }
   | { type: 'sqlserver'; data: SQLServerDataSource }
+  | { type: 'monetdb'; data: MonetDBDataSource }
   | { type: 'snowflake'; data: SnowflakeDataSource }
 
 export type DataSourceType = DataSource['type']
@@ -57,6 +61,7 @@ export const DataSourceType = z.enum([
   'sqlserver',
   'trino',
   'snowflake',
+  'monetdb',
 ] as const)
 
 // Ensure Zod enum stays in sync with `DataSourceType`
@@ -86,6 +91,7 @@ export async function listDataSources(
     sqlserver.listSQLServerDataSources(workspaceId),
     trino.listTrinoDataSources(workspaceId),
     snowflake.listSnowflakeDataSources(workspaceId),
+    monetdb.listMonetDbDataSources(workspaceId),
   ])
 
   return dbs.reduce((acc, cur) => acc.concat(cur), [])
@@ -145,6 +151,12 @@ export async function getDatasource(
         .then((data): DataSource | null =>
           data ? { type: 'sqlserver', data } : null
         )
+    case 'monetdb':
+      return monetdb
+        .getMonetDbDataSource(workspaceId, id)
+        .then((data): DataSource | null =>
+          data ? { type: 'monetdb', data } : null
+      )
     case 'snowflake':
       return snowflake
         .getSnowflakeDataSource(workspaceId, id)
@@ -208,6 +220,19 @@ export async function getDatasourcePassword(
     case 'bigquery':
     case 'athena':
       return ''
+    case 'monetdb':
+      return prisma()
+        .monetDBDataSource.findFirstOrThrow({
+          where: {
+            id: datasource.data.id,
+          },
+          select: {
+            password: true,
+          },
+        })
+        .then((row) =>
+          row.password !== null ? decrypt(row.password, encryptionKey) : ''
+        )
     case 'snowflake':
       return prisma()
         .snowflakeDataSource.findFirstOrThrow({
@@ -304,6 +329,12 @@ export async function getDatabaseURL(
       )
       return `mssql+pymssql://${ds.data.username}:${password}@${ds.data.host}:${ds.data.port}/${ds.data.database}`
     }
+    case 'monetdb': {
+      const password = encodeURIComponent(
+        await getDatasourcePassword(ds, encryptionKey)
+      )
+      return `monetdb://${ds.data.username}:${password}@${ds.data.host}:${ds.data.port}/${ds.data.database}`
+    }
     case 'snowflake': {
       const password = encodeURIComponent(
         await getDatasourcePassword(ds, encryptionKey)
@@ -364,6 +395,18 @@ export async function getCredentialsInfo(
         sslrootcert: decrypt(mysql.cert, encryptionKey),
       }
     }
+    case 'monetdb': {
+      const monetdb = await prisma().monetDBDataSource.findFirstOrThrow({
+        where: { id: ds.data.id },
+      })
+      if (!monetdb.cert) {
+        return null
+      }
+
+      return {
+        sslrootcert: decrypt(monetdb.cert, encryptionKey),
+      }
+    }
     case 'snowflake':
       return null
   }
diff --git a/packages/database/src/datasources/monetdb.ts b/packages/database/src/datasources/monetdb.ts
new file mode 100644
index 00000000..a3bfb0b9
--- /dev/null
+++ b/packages/database/src/datasources/monetdb.ts
@@ -0,0 +1,149 @@
+import { MonetDBDataSource as PrismaMonetDBDataSource } from '@prisma/client'
+
+import { DataSource } from './index.js'
+import prisma from '../index.js'
+import { decrypt, encrypt } from './crypto.js'
+
+export type MonetDBDataSource = Omit<
+    PrismaMonetDBDataSource,
+  | 'createdAt'
+  | 'updatedAt'
+  | 'lastConnection'
+  | 'password'
+  | 'cert'
+  | 'structure'
+> & {
+  createdAt: string
+  updatedAt: string
+  lastConnection: string | null
+}
+
+function toMonedDbDataSource(
+  pdataSource: PrismaMonetDBDataSource
+): MonetDBDataSource {
+  return {
+    id: pdataSource.id,
+    name: pdataSource.name,
+    host: pdataSource.isDemo ? '' : pdataSource.host,
+    port: pdataSource.isDemo ? '' : pdataSource.port,
+    database: pdataSource.isDemo ? '' : pdataSource.database,
+    username: pdataSource.isDemo ? '' : pdataSource.username,
+    notes: pdataSource.notes,
+    workspaceId: pdataSource.workspaceId,
+    readOnly: pdataSource.readOnly,
+    isDemo: pdataSource.isDemo,
+    createdAt: pdataSource.createdAt.toISOString(),
+    updatedAt: pdataSource.updatedAt.toISOString(),
+    connStatus: pdataSource.connStatus,
+    connError: pdataSource.connError,
+    lastConnection: pdataSource.lastConnection?.toISOString() ?? null,
+  }
+}
+
+export async function getMonetDbCert(
+  ds: MonetDBDataSource,
+  encryptionKey: string
+): Promise<Buffer | null> {
+  const cert = await prisma()
+    .monetDBDataSource.findUnique({
+      where: { id: ds.id },
+      select: { cert: true },
+    })
+    .then((row) => row?.cert)
+
+  if (!cert) {
+    return null
+  }
+
+  const hex = decrypt(cert, encryptionKey)
+  return Buffer.from(hex, 'hex')
+}
+
+export async function getMonetDbPassword(
+  ds: MonetDBDataSource,
+  encryptionKey: string
+): Promise<string> {
+  const password = await prisma()
+    .monetDBDataSource.findUnique({
+      where: { id: ds.id },
+      select: { password: true },
+    })
+    .then((row) => row?.password)
+
+  if (!password) {
+    throw new Error(`Fail to fetch password for datasource ${ds.id}`)
+  }
+
+  return decrypt(password, encryptionKey)
+}
+
+export async function listMonetDbDataSources(
+  workspaceId: string
+): Promise<DataSource[]> {
+  const fromDB = await prisma().monetDBDataSource.findMany({
+    where: { workspaceId },
+  })
+
+  return fromDB.map(
+    (pd): DataSource => ({ type: 'monetdb', data: toMonedDbDataSource(pd) })
+  )
+}
+
+export async function updateMonedDbDataSource(
+  data: Partial<Omit<PrismaMonetDBDataSource, 'createdAt' | 'updatedAt'>>,
+  encryptionKey: string
+): Promise<MonetDBDataSource> {
+  return prisma()
+    .monetDBDataSource.update({
+      where: { id: data.id },
+      data: {
+        ...data,
+        password: data.password
+          ? encrypt(data.password, encryptionKey)
+          : undefined,
+        cert: data.cert ? encrypt(data.cert, encryptionKey) : undefined,
+      },
+    })
+    .then(toMonedDbDataSource)
+}
+
+export async function createMonetDbDataSource(
+  data: Omit<
+  PrismaMonetDBDataSource,
+    'id' | 'createdAt' | 'updatedAt' | 'structure' | 'isDemo'
+  >,
+  encryptionKey: string
+): Promise<MonetDBDataSource> {
+  return prisma()
+    .monetDBDataSource.create({
+      data: {
+        ...data,
+        password: encrypt(data.password, encryptionKey),
+        cert: data.cert ? encrypt(data.cert, encryptionKey) : undefined,
+      },
+    })
+    .then(toMonedDbDataSource)
+}
+
+export async function getMonetDbDataSource(
+  workspaceId: string,
+  id: string
+): Promise<MonetDBDataSource | null> {
+  const fromDB = await prisma().monetDBDataSource.findUnique({
+    where: { workspaceId, id },
+  })
+  if (!fromDB) {
+    return null
+  }
+
+  return toMonedDbDataSource(fromDB)
+}
+
+export async function deleteMonetDbDataSource(
+  workspaceId: string,
+  id: string
+): Promise<MonetDBDataSource> {
+  return toMonedDbDataSource(
+    await prisma().monetDBDataSource.delete({ where: { workspaceId, id } })
+  )
+}