diff --git a/.gitignore b/.gitignore
index 17e107f205..f3009a2cd4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -196,7 +196,9 @@ packages/app-desktop/commands/toggleSafeMode.js
 packages/app-desktop/commands/toggleTabMovesFocus.js
 packages/app-desktop/gui/AiDegradedNotice.js
 packages/app-desktop/gui/Button/Button.js
+packages/app-desktop/gui/ChatPanel/ChatHistory.js
 packages/app-desktop/gui/ChatPanel/ChatMessageItem.js
+packages/app-desktop/gui/ChatPanel/ChatPanel.test.js
 packages/app-desktop/gui/ChatPanel/ChatPanel.js
 packages/app-desktop/gui/ClipperConfigScreen.js
 packages/app-desktop/gui/ConfigScreen/ButtonBar.js
@@ -536,6 +538,7 @@ packages/app-desktop/gui/WindowCommandsAndDialogs/commands/newNote.js
 packages/app-desktop/gui/WindowCommandsAndDialogs/commands/newSubFolder.js
 packages/app-desktop/gui/WindowCommandsAndDialogs/commands/newTodo.js
 packages/app-desktop/gui/WindowCommandsAndDialogs/commands/newWhiteboard.js
+packages/app-desktop/gui/WindowCommandsAndDialogs/commands/openAiChatConversation.js
 packages/app-desktop/gui/WindowCommandsAndDialogs/commands/openFolder.js
 packages/app-desktop/gui/WindowCommandsAndDialogs/commands/openFolderDialog.js
 packages/app-desktop/gui/WindowCommandsAndDialogs/commands/openItem.js
@@ -1499,6 +1502,9 @@ packages/lib/mimeUtils.test.js
 packages/lib/models/Alarm.js
 packages/lib/models/BaseItem.test.js
 packages/lib/models/BaseItem.js
+packages/lib/models/ChatConversation.test.js
+packages/lib/models/ChatConversation.js
+packages/lib/models/ChatMessage.js
 packages/lib/models/ConflictNoteState.js
 packages/lib/models/Folder.publishing.test.js
 packages/lib/models/Folder.sharing.test.js
@@ -1691,6 +1697,7 @@ packages/lib/services/database/migrations/50.js
 packages/lib/services/database/migrations/51.js
 packages/lib/services/database/migrations/52.js
 packages/lib/services/database/migrations/53.js
+packages/lib/services/database/migrations/54.js
 packages/lib/services/database/migrations/index.js
 packages/lib/services/database/sqlStringToLines.js
 packages/lib/services/database/types.js
diff --git a/.ignore.eslint b/.ignore.eslint
index dbf5d2f24c..2548ff263b 100644
--- a/.ignore.eslint
+++ b/.ignore.eslint
@@ -222,7 +222,9 @@ packages/app-desktop/commands/toggleSafeMode.js
 packages/app-desktop/commands/toggleTabMovesFocus.js
 packages/app-desktop/gui/AiDegradedNotice.js
 packages/app-desktop/gui/Button/Button.js
+packages/app-desktop/gui/ChatPanel/ChatHistory.js
 packages/app-desktop/gui/ChatPanel/ChatMessageItem.js
+packages/app-desktop/gui/ChatPanel/ChatPanel.test.js
 packages/app-desktop/gui/ChatPanel/ChatPanel.js
 packages/app-desktop/gui/ClipperConfigScreen.js
 packages/app-desktop/gui/ConfigScreen/ButtonBar.js
@@ -562,6 +564,7 @@ packages/app-desktop/gui/WindowCommandsAndDialogs/commands/newNote.js
 packages/app-desktop/gui/WindowCommandsAndDialogs/commands/newSubFolder.js
 packages/app-desktop/gui/WindowCommandsAndDialogs/commands/newTodo.js
 packages/app-desktop/gui/WindowCommandsAndDialogs/commands/newWhiteboard.js
+packages/app-desktop/gui/WindowCommandsAndDialogs/commands/openAiChatConversation.js
 packages/app-desktop/gui/WindowCommandsAndDialogs/commands/openFolder.js
 packages/app-desktop/gui/WindowCommandsAndDialogs/commands/openFolderDialog.js
 packages/app-desktop/gui/WindowCommandsAndDialogs/commands/openItem.js
@@ -1525,6 +1528,9 @@ packages/lib/mimeUtils.test.js
 packages/lib/models/Alarm.js
 packages/lib/models/BaseItem.test.js
 packages/lib/models/BaseItem.js
+packages/lib/models/ChatConversation.test.js
+packages/lib/models/ChatConversation.js
+packages/lib/models/ChatMessage.js
 packages/lib/models/ConflictNoteState.js
 packages/lib/models/Folder.publishing.test.js
 packages/lib/models/Folder.sharing.test.js
@@ -1717,6 +1723,7 @@ packages/lib/services/database/migrations/50.js
 packages/lib/services/database/migrations/51.js
 packages/lib/services/database/migrations/52.js
 packages/lib/services/database/migrations/53.js
+packages/lib/services/database/migrations/54.js
 packages/lib/services/database/migrations/index.js
 packages/lib/services/database/sqlStringToLines.js
 packages/lib/services/database/types.js
diff --git a/packages/app-desktop/app.reducer.test.ts b/packages/app-desktop/app.reducer.test.ts
index 8739be4fea..bafd778617 100644
--- a/packages/app-desktop/app.reducer.test.ts
+++ b/packages/app-desktop/app.reducer.test.ts
@@ -1,9 +1,25 @@
 import { ChatRole, ChatToolCall, ChatToolMessage } from '@joplin/lib/services/ai/types';
 import { AiChatMessage, AppState, createAppDefaultWindowState } from './app.reducer';
 import appReducer, { createAppDefaultState } from './app.reducer';
-import { defaultWindowId } from '@joplin/lib/reducer';
 
 describe('app.reducer', () => {
+	it('should clear a deleted conversation from matching windows and keep other conversations', () => {
+		const messages: AiChatMessage[] = [{ id: 'question', createdTime: 1, role: 'user', text: 'Question', raw: [], noteId: '', noteTitle: '' }];
+		const state = createAppDefaultState({});
+		state.aiChatConversationId = 'deleted';
+		state.aiChatMessages = messages;
+		state.backgroundWindows = {
+			second: { ...createAppDefaultWindowState(), windowId: 'second', aiChatConversationId: 'deleted', aiChatMessages: messages },
+			third: { ...createAppDefaultWindowState(), windowId: 'third', aiChatConversationId: 'other', aiChatMessages: messages },
+		};
+		const result = appReducer(state, { type: 'AI_CHAT_DELETE', conversationId: 'deleted' });
+		expect(result.aiChatConversationId).toBeNull();
+		expect(result.aiChatMessages).toEqual([]);
+		expect(result.backgroundWindows.second.aiChatConversationId).toBeNull();
+		expect(result.backgroundWindows.second.aiChatMessages).toEqual([]);
+		expect(result.backgroundWindows.third.aiChatConversationId).toBe('other');
+		expect(result.backgroundWindows.third.aiChatMessages).toEqual(messages);
+	});
 
 	it('should handle DIALOG_OPEN', async () => {
 		const state: AppState = createAppDefaultState({});
@@ -107,11 +123,15 @@ describe('app.reducer', () => {
 	it('should build AI chat history', () => {
 		let state: AppState = {
 			...createAppDefaultState({}),
+			aiChatConversationId: 'chat-1',
 		};
 
 		let idCounter = 0;
 		const buildMessage = (role: ChatRole.User | ChatRole.Assistant, content: string, toolCalls: ChatToolCall[]) => ({
 			id: `id-${idCounter++}`,
+			createdTime: 1,
+			noteId: 'note-a',
+			noteTitle: 'A',
 			role,
 			text: content,
 			raw: [
@@ -125,12 +145,12 @@ describe('app.reducer', () => {
 
 		state = appReducer(state, {
 			type: 'AI_CHAT_APPEND',
-			windowId: defaultWindowId,
+			conversationId: 'chat-1',
 			message: buildMessage(ChatRole.User, 'Test', []),
 		});
 		state = appReducer(state, {
 			type: 'AI_CHAT_APPEND',
-			windowId: defaultWindowId,
+			conversationId: 'chat-1',
 			message: buildMessage(
 				ChatRole.Assistant,
 				'Testing',
@@ -139,7 +159,7 @@ describe('app.reducer', () => {
 		});
 		state = appReducer(state, {
 			type: 'AI_CHAT_ADD_TOOL_RESULT',
-			windowId: defaultWindowId,
+			conversationId: 'chat-1',
 			toolCall: ({
 				role: ChatRole.Tool,
 				toolName: 'testTool',
@@ -155,13 +175,5 @@ describe('app.reducer', () => {
 			{ id: 'id-0', role: 'user', text: 'Test', raw: [{ role: 'user' }] },
 			{ id: 'id-1', role: 'assistant', text: 'Testing' },
 		]);
-
-
-		state = appReducer(state, {
-			type: 'AI_CHAT_RESET',
-			windowId: defaultWindowId,
-		});
-
-		expect(state.aiChatMessages).toEqual([]);
 	});
 });
diff --git a/packages/app-desktop/app.reducer.ts b/packages/app-desktop/app.reducer.ts
index b08dda6d70..1ccf8f4f6a 100644
--- a/packages/app-desktop/app.reducer.ts
+++ b/packages/app-desktop/app.reducer.ts
@@ -5,12 +5,15 @@ import iterateItems from './gui/ResizableLayout/utils/iterateItems';
 import { LayoutItem } from './gui/ResizableLayout/utils/types';
 import validateLayout from './gui/ResizableLayout/utils/validateLayout';
 import Logger from '@joplin/utils/Logger';
-import { ChatMessage } from '@joplin/lib/services/ai/types';
+import { ChatMessage, ChatRole } from '@joplin/lib/services/ai/types';
 
 const logger = Logger.create('app.reducer');
 
 export interface AiChatMessage {
 	id: string;
+	createdTime: number;
+	noteId: string;
+	noteTitle: string;
 	role: 'user' | 'assistant' | 'error' | 'separator';
 	text: string;
 	hide?: boolean;
@@ -78,6 +81,7 @@ export interface AppWindowState extends WindowState {
 	// In window state so the conversation survives panel hide/show (the
 	// layout container can swap component types and unmount the panel).
 	aiChatMessages: AiChatMessage[];
+	aiChatConversationId: string|null;
 	// Layout for secondary windows
 	secondaryWindowLayout: LayoutItem|null;
 }
@@ -115,6 +119,7 @@ export const createAppDefaultWindowState = (): AppWindowState => {
 		whiteboardForceMarkdown: {},
 		activeNoteIsWhiteboard: false,
 		aiChatMessages: [],
+		aiChatConversationId: null,
 		secondaryWindowLayout: null,
 	};
 };
@@ -304,43 +309,44 @@ export default function(state: AppState, action: any) {
 			);
 			break;
 
+		case 'AI_CHAT_DELETE':
+			newState = produce(state, draft => {
+				for (const windowState of stateUtils.allWindowStates(draft)) {
+					if (windowState.aiChatConversationId !== action.conversationId) continue;
+					windowState.aiChatConversationId = null;
+					windowState.aiChatMessages = [];
+				}
+			});
+			break;
+
+		case 'AI_CHAT_OPEN':
+			newState = produce(state, draft => {
+				const openConversation = action.conversationId && stateUtils.allWindowStates(state)
+					.find(windowState => windowState.aiChatConversationId === action.conversationId);
+				const windowState = stateUtils.windowStateById(draft, action.windowId);
+				windowState.aiChatConversationId = action.conversationId;
+				windowState.aiChatMessages = openConversation ? openConversation.aiChatMessages : action.messages;
+			});
+			break;
+
 		case 'AI_CHAT_APPEND':
-			newState = withWindowStateUpdated(
-				state, action.windowId, 'aiChatMessages', messages => [...messages, action.message as AiChatMessage],
-			);
-			break;
-
 		case 'AI_CHAT_ADD_TOOL_RESULT':
-			newState = withWindowStateUpdated(
-				state, action.windowId, 'aiChatMessages', messages => {
-					let lastMessage = messages[messages.length - 1];
-					if (lastMessage) {
-						lastMessage = {
-							...lastMessage,
-							raw: [
-								...lastMessage.raw,
-								action.toolCall,
-							],
-						};
-
-						return [...messages.slice(0, messages.length - 1), lastMessage];
-					}
-
-					return messages;
-				},
-			);
-			break;
-
 		case 'AI_CHAT_REMOVE':
-			newState = withWindowStateUpdated(
-				state, action.windowId, 'aiChatMessages', messages => messages.filter(m => m.id !== action.id),
-			);
-			break;
-
-		case 'AI_CHAT_RESET':
-			newState = withWindowStateUpdated(
-				state, action.windowId, 'aiChatMessages', (): AiChatMessage[] => [],
-			);
+			newState = produce(state, draft => {
+				for (const windowState of stateUtils.allWindowStates(draft)) {
+					if (windowState.aiChatConversationId !== action.conversationId) continue;
+					if (action.type === 'AI_CHAT_APPEND') {
+						windowState.aiChatMessages.push(action.message);
+					} else if (action.type === 'AI_CHAT_REMOVE') {
+						windowState.aiChatMessages = windowState.aiChatMessages.filter(message => message.id !== action.id);
+					} else {
+						const message = windowState.aiChatMessages.find(message => message.raw.some(entry =>
+							entry.role === ChatRole.Assistant && entry.toolCalls?.some(call => call.callId === action.toolCall.toolCallId),
+						));
+						message?.raw.push(action.toolCall);
+					}
+				}
+			});
 			break;
 
 		case 'AI_STATUS_UPDATE':
diff --git a/packages/app-desktop/gui/ChatPanel/ChatHistory.scss b/packages/app-desktop/gui/ChatPanel/ChatHistory.scss
new file mode 100644
index 0000000000..d476c9fde6
--- /dev/null
+++ b/packages/app-desktop/gui/ChatPanel/ChatHistory.scss
@@ -0,0 +1,140 @@
+@mixin chat-history-input {
+	box-sizing: border-box;
+	font: inherit;
+	color: var(--joplin-color);
+	background-color: var(--joplin-background-color);
+	border: 1px solid var(--joplin-divider-color);
+	border-radius: 4px;
+}
+
+.chat-history {
+	position: absolute;
+	top: 100%;
+	left: 30px;
+	right: 30px;
+	z-index: 10;
+	display: flex;
+	flex-direction: column;
+	max-width: 400px;
+	padding: 6px 10px 10px;
+	font-weight: normal;
+	background-color: var(--joplin-background-color);
+	border-bottom: 1px solid var(--joplin-divider-color);
+	box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
+
+	> .search {
+		flex-shrink: 0;
+	}
+}
+
+.conversation-search {
+	position: relative;
+	display: flex;
+	align-items: center;
+
+	> .icon {
+		position: absolute;
+		left: 8px;
+		color: var(--joplin-color-faded);
+		pointer-events: none;
+	}
+
+	> .field {
+		@include chat-history-input;
+		width: 100%;
+		padding: 6px 6px 6px 26px;
+	}
+}
+
+.conversation-list {
+	list-style: none;
+	margin: 6px 0 0;
+	padding: 0;
+	max-height: 200px;
+	overflow-y: auto;
+}
+
+.conversation-row {
+	display: flex;
+	align-items: center;
+	line-height: 16px;
+	cursor: pointer;
+
+	&.-current {
+		font-weight: bold;
+		background-color: var(--joplin-selected-color);
+	}
+
+	&:hover:not(.-current) {
+		background-color: var(--joplin-background-color-hover3);
+	}
+
+	> .open {
+		flex: 1;
+		min-width: 0;
+	}
+
+	> .title-input {
+		@include chat-history-input;
+		flex: 1;
+		min-width: 0;
+		margin: 6px 20px;
+		padding: 3px 4px;
+	}
+
+	> .actions {
+		flex-shrink: 0;
+		margin-right: 20px;
+	}
+
+	&:hover,
+	&:focus-within {
+		--chat-history-timestamp-display: none;
+	}
+
+	&:hover > .actions,
+	&:focus-within > .actions {
+		display: flex;
+	}
+}
+
+.conversation-link {
+	display: flex;
+	padding: 10px 20px;
+	gap: 18px;
+	text-align: left;
+	font: inherit;
+	color: inherit;
+	background: none;
+	border: none;
+	cursor: pointer;
+
+	> .title {
+		flex: 1;
+		min-width: 0;
+		white-space: nowrap;
+		overflow: hidden;
+		text-overflow: ellipsis;
+	}
+
+	> .timestamp {
+		display: var(--chat-history-timestamp-display, initial);
+		flex-shrink: 0;
+		text-align: right;
+		color: var(--joplin-color-faded);
+	}
+}
+
+.conversation-actions {
+	display: none;
+	gap: 10px;
+	align-items: center;
+
+	> button {
+		display: flex;
+		color: var(--joplin-color3);
+		cursor: pointer;
+		font-size: 16px;
+		line-height: 1;
+	}
+}
diff --git a/packages/app-desktop/gui/ChatPanel/ChatHistory.tsx b/packages/app-desktop/gui/ChatPanel/ChatHistory.tsx
new file mode 100644
index 0000000000..d936ddce24
--- /dev/null
+++ b/packages/app-desktop/gui/ChatPanel/ChatHistory.tsx
@@ -0,0 +1,112 @@
+import * as React from 'react';
+import { useState } from 'react';
+import { _ } from '@joplin/lib/locale';
+import { formatMsToRelativeTime } from '@joplin/utils/time';
+
+export interface Conversation {
+	id: string;
+	title: string;
+	updated_time: number;
+}
+
+interface Props {
+	conversations: Conversation[];
+	currentConversationId?: string|null;
+	id: string;
+	popupRef: React.Ref<HTMLDivElement>;
+	onSearchChange: (search: string)=> void;
+	onOpen: (conversationId: string)=> void;
+	onRename: (conversation: Conversation, title: string)=> void;
+	onDelete: (conversationId: string)=> void;
+	onClose: ()=> void;
+}
+
+const ChatHistory: React.FC<Props> = props => {
+	const [search, setSearch] = useState('');
+	const [editingId, setEditingId] = useState<string|null>(null);
+	const [draftTitle, setDraftTitle] = useState('');
+
+	const startEditing = (conversation: Conversation) => {
+		setEditingId(conversation.id);
+		setDraftTitle(conversation.title);
+	};
+
+	const stopEditing = () => setEditingId(null);
+
+	const onTitleKeyDown = (event: React.KeyboardEvent<HTMLInputElement>, conversation: Conversation) => {
+		if (event.nativeEvent.isComposing) return;
+		if (event.key === 'Escape') {
+			event.stopPropagation();
+			stopEditing();
+			return;
+		}
+		if (event.key !== 'Enter') return;
+		event.preventDefault();
+		props.onRename(conversation, draftTitle);
+		stopEditing();
+	};
+
+	const onPopupKeyDown = (event: React.KeyboardEvent<HTMLDivElement>) => {
+		if (event.nativeEvent.isComposing || event.key !== 'Escape') return;
+		event.stopPropagation();
+		props.onClose();
+	};
+
+	return <div className='chat-history' id={props.id} ref={props.popupRef} onKeyDown={onPopupKeyDown}>
+		<div className='conversation-search search'>
+			<i className='icon icon-search' aria-hidden='true'/>
+			<input
+				className='field'
+				type='search'
+				autoFocus
+				aria-label={_('Search conversations')}
+				placeholder={_('Search conversations')}
+				value={search}
+				onChange={event => {
+					setSearch(event.target.value);
+					props.onSearchChange(event.target.value);
+				}}
+			/>
+		</div>
+		<ul className='conversation-list' aria-label={_('Conversations')}>
+			{props.conversations.map(conversation => {
+				const current = conversation.id === props.currentConversationId;
+				const title = conversation.title || _('(untitled)');
+				const editing = conversation.id === editingId;
+				return <li key={conversation.id} className={`conversation-row${current ? ' -current' : ''}`} aria-current={current ? 'true' : undefined}
+					onClick={event => {
+						if (event.target === event.currentTarget) props.onOpen(conversation.id);
+					}}
+				>
+					{editing ? (
+						<input
+							className='title-input'
+							type='text'
+							autoFocus
+							aria-label={_('Conversation title')}
+							value={draftTitle}
+							onChange={event => setDraftTitle(event.target.value)}
+							onKeyDown={event => onTitleKeyDown(event, conversation)}
+							onBlur={stopEditing}
+						/>
+					) : (
+						<button className='conversation-link open' type='button' onClick={() => props.onOpen(conversation.id)}>
+							<span className='title'>{title}</span>
+							<span className='timestamp'>{formatMsToRelativeTime(conversation.updated_time)}</span>
+						</button>
+					)}
+					<div className='conversation-actions actions'>
+						<button className='flat-button' type='button' title={_('Rename')} aria-label={_('Rename')} onClick={() => startEditing(conversation)}>
+							<i className='fa fa-pen' aria-hidden='true'/>
+						</button>
+						<button className='flat-button' type='button' title={_('Delete')} aria-label={_('Delete')} onClick={() => props.onDelete(conversation.id)}>
+							<i className='fas fa-trash' aria-hidden='true'/>
+						</button>
+					</div>
+				</li>;
+			})}
+		</ul>
+	</div>;
+};
+
+export default ChatHistory;
diff --git a/packages/app-desktop/gui/ChatPanel/ChatPanel.test.tsx b/packages/app-desktop/gui/ChatPanel/ChatPanel.test.tsx
new file mode 100644
index 0000000000..83280d5043
--- /dev/null
+++ b/packages/app-desktop/gui/ChatPanel/ChatPanel.test.tsx
@@ -0,0 +1,200 @@
+import * as React from 'react';
+import { act, fireEvent, render, waitFor, within } from '@testing-library/react';
+import BaseModel from '@joplin/lib/BaseModel';
+import ChatConversation from '@joplin/lib/models/ChatConversation';
+import Note from '@joplin/lib/models/Note';
+import CommandService from '@joplin/lib/services/CommandService';
+import { runNoteChat } from '@joplin/lib/services/ai/noteChat';
+import { ChatRole } from '@joplin/lib/services/ai/types';
+import { setupDatabaseAndSynchronizer, switchClient } from '@joplin/lib/testing/test-utils';
+import appReducer, { AiChatMessage, createAppDefaultState, createAppDefaultWindowState } from '../../app.reducer';
+import ChatPanel from './ChatPanel';
+import { WindowIdContext } from '../NewWindowOrIFrame';
+import uuid from '@joplin/lib/uuid';
+import '../../utils/window/eventHandlerOverrides';
+
+jest.mock('@joplin/lib/services/ai/noteChat', () => ({ runNoteChat: jest.fn() }));
+jest.mock('./ChatMessageItem', () => ({ message }: { message: { text: string } }) => <div>{message.text}</div>);
+
+const Panel = ChatPanel.WrappedComponent;
+const message: AiChatMessage = { id: 'question', createdTime: 1, role: 'user', text: 'Question', raw: [], noteId: 'note-a', noteTitle: 'A' };
+
+const renderPanel = (props: Partial<React.ComponentProps<typeof Panel>> = {}) => render(
+	<WindowIdContext.Provider value='second'><Panel
+		themeId={1} available={true} unavailableHint='' providerType='joplin-cloud'
+		noteId={null} noteTitle='' noteIsEncrypted={false} messages={[]} aiDegraded={false} dispatch={jest.fn()}
+		showToolbarButton={false}
+		{...props}
+	/></WindowIdContext.Provider>,
+);
+
+const openHistory = async (view: ReturnType<typeof render>) => {
+	await act(async () => { fireEvent.click(view.getByTitle('Chat history')); });
+};
+
+const saveConversation = async (id: string, title: string, updatedTime = 1) => {
+	await ChatConversation.save({ id, title, created_time: 1, updated_time: updatedTime }, { isNew: true, autoTimestamp: false });
+};
+
+const saveMessage = async (conversationId: string, text: string) => {
+	await ChatConversation.addMessage(conversationId, { id: uuid.create(), createdTime: 1, role: 'user', text, raw: [], noteId: '', noteTitle: '' });
+};
+
+describe('ChatPanel', () => {
+	let modelDispatch: jest.Mock;
+
+	beforeEach(async () => {
+		await setupDatabaseAndSynchronizer(1);
+		await switchClient(1);
+		Element.prototype.scrollIntoView = jest.fn();
+		jest.mocked(runNoteChat).mockReset();
+		modelDispatch = jest.fn();
+		BaseModel.dispatch = modelDispatch;
+	});
+
+	afterEach(() => {
+		jest.restoreAllMocks();
+		BaseModel.dispatch = () => {};
+	});
+
+	it('should search conversation titles and messages', async () => {
+		await saveConversation('shopping', 'Shopping list');
+		await saveConversation('travel', 'Travel plans');
+		await saveMessage('travel', 'Visit Paris');
+		const view = renderPanel();
+		await openHistory(view);
+		await view.findByText('Shopping list');
+		const search = view.getByRole('searchbox', { name: 'Search conversations' });
+		fireEvent.change(search, { target: { value: 'Shopping' } });
+		await waitFor(() => expect(view.getAllByRole('listitem')).toHaveLength(1));
+		expect(view.getByText('Shopping list')).toBeTruthy();
+		fireEvent.change(search, { target: { value: 'Paris' } });
+		expect(await view.findByText('Travel plans')).toBeTruthy();
+		expect(view.getAllByRole('listitem')).toHaveLength(1);
+		fireEvent.change(search, { target: { value: '' } });
+		expect(await view.findByText('Shopping list')).toBeTruthy();
+		expect(view.getAllByRole('listitem')).toHaveLength(2);
+	});
+
+	it('should rename a conversation inline when Enter is pressed', async () => {
+		await saveConversation('chat-1', 'Old title');
+		const view = renderPanel();
+		await openHistory(view);
+		const row = (await view.findByText('Old title')).closest('li');
+		fireEvent.click(within(row).getByRole('button', { name: 'Rename' }));
+		const input = within(row).getByRole('textbox', { name: 'Conversation title' });
+		fireEvent.change(input, { target: { value: 'New title' } });
+		await act(async () => { fireEvent.keyDown(input, { key: 'Enter' }); });
+		expect(await view.findByText('New title')).toBeTruthy();
+		expect(view.queryByRole('textbox', { name: 'Conversation title' })).toBeNull();
+		expect(await ChatConversation.load('chat-1')).toMatchObject({ title: 'New title' });
+	});
+
+	it('should close the history popup when clicking outside of it', async () => {
+		await saveConversation('chat-1', 'Saved chat');
+		const view = renderPanel();
+		await openHistory(view);
+		await view.findByText('Saved chat');
+		fireEvent.mouseDown(view.getByRole('searchbox', { name: 'Search conversations' }));
+		expect(view.getByText('Saved chat')).toBeTruthy();
+		fireEvent.mouseDown(view.getByRole('textbox', { name: 'Chat message' }));
+		await waitFor(() => expect(view.queryByText('Saved chat')).toBeNull());
+	});
+
+	it('should delete the selected conversation and its messages', async () => {
+		await saveConversation('delete-chat', 'Delete this chat');
+		await saveConversation('keep-chat', 'Keep this chat');
+		await saveMessage('delete-chat', 'Delete this message');
+		await saveMessage('keep-chat', 'Keep this message');
+		const dispatch = jest.fn();
+		const view = renderPanel({ conversationId: 'delete-chat', dispatch });
+		await openHistory(view);
+		const row = (await view.findByText('Delete this chat')).closest('li');
+		await act(async () => { fireEvent.click(within(row).getByRole('button', { name: 'Delete' })); });
+		await waitFor(() => expect(view.queryByText('Delete this chat')).toBeNull());
+		expect(view.getByText('Keep this chat')).toBeTruthy();
+		expect((await ChatConversation.history()).map(conversation => conversation.id)).toEqual(['keep-chat']);
+		expect(await ChatConversation.messages('keep-chat')).toMatchObject([{ text: 'Keep this message' }]);
+		await saveConversation('delete-chat', 'Recreated chat');
+		expect(await ChatConversation.messages('delete-chat')).toEqual([]);
+		expect(dispatch).toHaveBeenCalledWith({ type: 'AI_CHAT_DELETE', conversationId: 'delete-chat' });
+	});
+
+	it('should keep history when New chat opens an empty conversation in the current window', async () => {
+		await saveConversation('chat-1', 'Current chat');
+		const dispatch = jest.fn();
+		const view = renderPanel({ conversationId: 'chat-1', messages: [message], dispatch });
+		await act(async () => { fireEvent.click(view.getByRole('button', { name: 'New chat' })); });
+		await waitFor(() => expect(dispatch).toHaveBeenCalled());
+		expect(await ChatConversation.load('chat-1')).toMatchObject({ title: 'Current chat' });
+		const action = dispatch.mock.calls[0][0];
+		expect(action).toEqual({ type: 'AI_CHAT_OPEN', windowId: 'second', conversationId: expect.any(String), messages: [] });
+		expect(action.conversationId).not.toBe('chat-1');
+		const state = createAppDefaultState({});
+		state.aiChatConversationId = 'main-chat';
+		state.aiChatMessages = [message];
+		state.backgroundWindows = { second: { ...createAppDefaultWindowState(), windowId: 'second' } };
+		const opened = appReducer(state, action);
+		expect(opened.aiChatConversationId).toBe('main-chat');
+		expect(opened.aiChatMessages).toEqual([message]);
+		expect(opened.backgroundWindows.second.aiChatConversationId).toBe(action.conversationId);
+		expect(opened.backgroundWindows.second.aiChatMessages).toEqual([]);
+	});
+
+	it('should not add an empty conversation to history', async () => {
+		await saveConversation('chat-1', 'Current chat');
+		const before = await ChatConversation.history();
+		const dispatch = jest.fn();
+		const view = renderPanel({ conversationId: 'chat-1', messages: [message], dispatch });
+		await act(async () => { fireEvent.click(view.getByRole('button', { name: 'New chat' })); });
+		await waitFor(() => expect(dispatch).toHaveBeenCalled());
+		const after = await ChatConversation.history();
+		expect(after).toHaveLength(before.length);
+	});
+
+	it('should open the selected history row in the current window', async () => {
+		await saveConversation('chat-1', 'Current chat');
+		await saveConversation('chat-2', 'Saved chat');
+		const execute = jest.spyOn(CommandService.instance(), 'executeInWindow').mockResolvedValue(undefined);
+		const view = renderPanel({ conversationId: 'chat-1', messages: [message] });
+		await openHistory(view);
+		fireEvent.click(await view.findByRole('button', { name: /Saved chat/ }));
+		await waitFor(() => expect(execute).toHaveBeenCalledWith('openAiChatConversation', { windowId: 'second', args: ['chat-2'] }));
+	});
+
+	it('should save the question and reply with the active note ID and title as they are created', async () => {
+		jest.spyOn(Note, 'load').mockResolvedValue({ id: 'note-a', title: 'A', body: '' });
+		jest.mocked(runNoteChat).mockImplementation(async (_context, _history, _text, _tools, onHistoryChanged) => {
+			onHistoryChanged([{ role: ChatRole.System, content: '' }, { role: ChatRole.Assistant, content: 'Reply' }]);
+			return [];
+		});
+		const view = renderPanel({ conversationId: 'chat-1', noteId: 'note-a', noteTitle: 'A' });
+		fireEvent.change(view.getByRole('textbox'), { target: { value: 'Question' } });
+		await act(async () => { fireEvent.click(view.getByRole('button', { name: 'Send' })); });
+		const expected = [
+			{ role: 'user', text: 'Question', noteId: 'note-a', noteTitle: 'A' },
+			{ role: 'assistant', text: 'Reply', noteId: 'note-a', noteTitle: 'A' },
+		];
+		await waitFor(async () => expect(await ChatConversation.messages('chat-1')).toMatchObject(expected));
+		expect(await ChatConversation.load('chat-1')).toMatchObject({ title: 'Question' });
+		const appended = modelDispatch.mock.calls.map(([action]) => action).filter(action => action.type === 'AI_CHAT_APPEND');
+		expect(appended).toMatchObject(expected.map(message => ({ conversationId: 'chat-1', message })));
+	});
+
+	it('should remove the saved question when the request fails before any reply', async () => {
+		jest.spyOn(Note, 'load').mockResolvedValue({ id: 'note-a', title: 'A', body: '' });
+		jest.mocked(runNoteChat).mockRejectedValue(new Error('Network down'));
+		const view = renderPanel({ conversationId: 'chat-1', noteId: 'note-a', noteTitle: 'A', dispatch: jest.fn() });
+		fireEvent.change(view.getByRole('textbox'), { target: { value: 'Question' } });
+		await act(async () => { fireEvent.click(view.getByRole('button', { name: 'Send' })); });
+		await waitFor(async () => expect(await ChatConversation.messages('chat-1')).toMatchObject([{ role: 'error', text: 'Network down' }]));
+	});
+
+	it('should assign an ID before messages are added to a new conversation', async () => {
+		const dispatch = jest.fn();
+		renderPanel({ dispatch });
+		await waitFor(() => expect(dispatch).toHaveBeenCalledWith({
+			type: 'AI_CHAT_OPEN', windowId: 'second', conversationId: expect.any(String), messages: [],
+		}));
+	});
+});
diff --git a/packages/app-desktop/gui/ChatPanel/ChatPanel.tsx b/packages/app-desktop/gui/ChatPanel/ChatPanel.tsx
index fcb42ff24d..b89ee2a5b7 100644
--- a/packages/app-desktop/gui/ChatPanel/ChatPanel.tsx
+++ b/packages/app-desktop/gui/ChatPanel/ChatPanel.tsx
@@ -10,7 +10,7 @@ import Logger from '@joplin/utils/Logger';
 import { stateUtils } from '@joplin/lib/reducer';
 import { AiChatMessage, AppState } from '../../app.reducer';
 import { runNoteChat } from '@joplin/lib/services/ai/noteChat';
-import { chatAvailability } from '@joplin/lib/services/ai/availability';
+import { AvailabilityReason, chatAvailability } from '@joplin/lib/services/ai/availability';
 import { WindowIdContext } from '../NewWindowOrIFrame';
 import AiDegradedNotice from '../AiDegradedNotice';
 import { ChatMessage, ChatRole, ChatToolMessage } from '@joplin/lib/services/ai/types';
@@ -19,6 +19,11 @@ import eventManager, { EventName, ItemChangeEvent } from '@joplin/lib/eventManag
 import { Second } from '@joplin/utils/time';
 import ChatMessageItem from './ChatMessageItem';
 import NavService from '@joplin/lib/services/NavService';
+import ChatConversation from '@joplin/lib/models/ChatConversation';
+import uuid from '@joplin/lib/uuid';
+import { focus } from '@joplin/lib/utils/focusHandler';
+import dialogs from '../dialogs';
+import ChatHistory, { Conversation } from './ChatHistory';
 import Button, { ButtonLevel } from '../Button/Button';
 
 const logger = Logger.create('ChatPanel');
@@ -26,12 +31,14 @@ const logger = Logger.create('ChatPanel');
 interface Props {
 	themeId: number;
 	available: boolean;
+	availabilityReason?: AvailabilityReason;
 	unavailableHint: string;
 	providerType: string;
 	noteId: string | null;
 	noteTitle: string;
 	noteIsEncrypted: boolean;
 	messages: AiChatMessage[];
+	conversationId?: string|null;
 	aiDegraded: boolean;
 	showToolbarButton: boolean;
 	dispatch: Dispatch;
@@ -39,8 +46,7 @@ interface Props {
 
 const disclosureSetting = 'ai.chat.disclosureAcknowledged';
 
-let nextMessageId = 0;
-const makeId = () => `m-${Date.now()}-${++nextMessageId}`;
+const makeId = () => uuid.create();
 
 const waitForNextNoteChangeOrTimeout = (noteId: string, timeout: number) => {
 	return new Promise<void>((resolve) => {
@@ -107,7 +113,40 @@ const useHasFocus = () => {
 const ChatPanel: React.FC<Props> = (props) => {
 	const { dispatch, messages } = props;
 	const [input, setInput] = useState('');
+	const [historyOpen, setHistoryOpen] = useState(false);
+	const historyId = useId();
+	const [conversations, setConversations] = useState<Conversation[]>([]);
+	const loadConversationHistory = useCallback(async (search = '') => {
+		try {
+			setConversations(await ChatConversation.history(search));
+		} catch (error) {
+			logger.error('Could not load chat conversations', error);
+		}
+	}, []);
+	const handleHistoryToggle = useCallback(async () => {
+		setHistoryOpen(!historyOpen);
+		if (historyOpen) return;
+		await loadConversationHistory();
+	}, [historyOpen, loadConversationHistory]);
+	const historyPopupRef = useRef<HTMLDivElement>(null);
+	const historyButtonRef = useRef<HTMLButtonElement>(null);
+	const closeHistory = useCallback(() => {
+		setHistoryOpen(false);
+		focus('ChatPanel::closeHistory', historyButtonRef.current);
+	}, []);
+	useEffect(() => {
+		if (!historyOpen) return () => {};
+		const onMouseDown = (event: MouseEvent) => {
+			const target = event.target as Node;
+			if (historyPopupRef.current?.contains(target) || historyButtonRef.current?.contains(target)) return;
+			setHistoryOpen(false);
+		};
+		const doc = historyButtonRef.current.ownerDocument;
+		doc.addEventListener('mousedown', onMouseDown);
+		return () => doc.removeEventListener('mousedown', onMouseDown);
+	}, [historyOpen]);
 	const [sending, setSending] = useState(false);
+	const archivingRef = useRef(false);
 	const [disclosureShown, setDisclosureShown] = useState<boolean>(() => {
 		try {
 			return !!Setting.value(disclosureSetting);
@@ -130,13 +169,35 @@ const ChatPanel: React.FC<Props> = (props) => {
 
 	const windowId = useContext(WindowIdContext);
 
-	const appendMessage = useCallback((message: AiChatMessage) => {
-		dispatch({ type: 'AI_CHAT_APPEND', windowId, message });
-	}, [dispatch, windowId]);
+	const appendMessage = useCallback(async (message: Omit<AiChatMessage, 'noteId' | 'noteTitle' | 'createdTime'>) => {
+		const fullMessage: AiChatMessage = { ...message, createdTime: Date.now(), noteId: props.noteId ?? '', noteTitle: props.noteId ? props.noteTitle : '' };
+		try {
+			await ChatConversation.addMessage(props.conversationId, fullMessage);
+		} catch (error) {
+			logger.error('Could not save chat message:', error);
+		}
+	}, [props.noteId, props.noteTitle, props.conversationId]);
 
-	const addToolResult = useCallback((result: ChatToolMessage) => {
-		dispatch({ type: 'AI_CHAT_ADD_TOOL_RESULT', windowId, toolCall: result });
-	}, [dispatch, windowId]);
+	const removeMessage = useCallback(async (id: string) => {
+		try {
+			await ChatConversation.removeMessage(props.conversationId, id);
+		} catch (error) {
+			logger.error('Could not remove chat message:', error);
+		}
+	}, [props.conversationId]);
+
+	const addToolResult = useCallback(async (result: ChatToolMessage) => {
+		try {
+			await ChatConversation.addToolResult(props.conversationId, result);
+		} catch (error) {
+			logger.error('Could not save chat tool result:', error);
+		}
+	}, [props.conversationId]);
+
+	useEffect(() => {
+		if (props.conversationId) return;
+		dispatch({ type: 'AI_CHAT_OPEN', windowId, conversationId: uuid.create(), messages });
+	}, [props.conversationId, dispatch, windowId, messages]);
 
 	// Drop a separator when the active note changes mid-conversation. Skip
 	// the first ever opened note (no prior context to separate from).
@@ -147,7 +208,7 @@ const ChatPanel: React.FC<Props> = (props) => {
 		if (messagesLengthRef.current === 0) return;
 
 		const text = _('— now viewing: %s —', props.noteTitle || _('(untitled)'));
-		appendMessage({
+		void appendMessage({
 			id: makeId(),
 			role: 'separator',
 			text,
@@ -172,14 +233,14 @@ const ChatPanel: React.FC<Props> = (props) => {
 
 	const handleCancel = useCallback(() => {
 		cancelRequest();
-		appendMessage({ id: makeId(), role: 'assistant', text: _('(Cancelled)'), raw: [] });
+		void appendMessage({ id: makeId(), role: 'assistant', text: _('(Cancelled)'), raw: [] });
 	}, [cancelRequest, appendMessage]);
 
 	const handleSend = useCallback(async () => {
 		const text = input.trim();
 		if (!text || sending) return;
 		if (!props.noteId) {
-			appendMessage({
+			void appendMessage({
 				id: makeId(), role: 'error', text: _('Open a note to start chatting.'), raw: [],
 			});
 			return;
@@ -194,7 +255,7 @@ const ChatPanel: React.FC<Props> = (props) => {
 		// send the prior user turn as history alongside the new prompt.
 		const userTurnId = makeId();
 		let hadVisibleResponse = false;
-		appendMessage({
+		void appendMessage({
 			id: userTurnId,
 			role: 'user',
 			text,
@@ -203,6 +264,7 @@ const ChatPanel: React.FC<Props> = (props) => {
 
 		try {
 			const note = await Note.load(props.noteId);
+			if (abortController.signal.aborted) return;
 			if (!note) throw new Error(`Note not found: ${props.noteId}`);
 
 			const getContext = async () => {
@@ -244,11 +306,11 @@ const ChatPanel: React.FC<Props> = (props) => {
 					if (entry.role === ChatRole.System) continue;
 
 					if (entry.role === ChatRole.Tool) {
-						addToolResult(entry);
+						void addToolResult(entry);
 					} else {
 						hadVisibleResponse ||= !entry.hide;
 
-						appendMessage({
+						void appendMessage({
 							id: makeId(),
 							role: entry.role,
 							text: entry.content,
@@ -295,7 +357,7 @@ const ChatPanel: React.FC<Props> = (props) => {
 						await changeListener;
 					},
 					displayError: (message) => {
-						appendMessage({ id: makeId(), role: 'error', text: message, raw: [] });
+						void appendMessage({ id: makeId(), role: 'error', text: message, raw: [] });
 					},
 				}, onHistoryChanged, abortController.signal,
 			);
@@ -304,30 +366,72 @@ const ChatPanel: React.FC<Props> = (props) => {
 			if (abortController.signal.aborted) return;
 
 			if (!hadVisibleResponse) {
-				dispatch({ type: 'AI_CHAT_REMOVE', windowId, id: userTurnId });
+				void removeMessage(userTurnId);
 				setInput(text);
 			}
-			appendMessage({ id: makeId(), role: 'error', text: error.message || _('Something went wrong.'), raw: [] });
+			void appendMessage({ id: makeId(), role: 'error', text: error.message || _('Something went wrong.'), raw: [] });
 		} finally {
 			setSending(false);
 		}
-	}, [input, sending, props.noteId, conversationTurns, windowId, addToolResult, appendMessage, dispatch, cancelRequest, abortControllerRef]);
+	}, [input, sending, props.noteId, conversationTurns, windowId, addToolResult, appendMessage, removeMessage, cancelRequest, abortControllerRef]);
 
 	const handleAcknowledgeDisclosure = useCallback(() => {
 		Setting.setValue(disclosureSetting, true);
 		setDisclosureShown(true);
 	}, []);
 
-	const handleReset = useCallback(() => {
+	const handleNewChat = useCallback(() => {
+		if (archivingRef.current) return;
 		cancelRequest();
-
-		dispatch({ type: 'AI_CHAT_RESET', windowId: windowId });
+		// Only saved once a message is sent so empty chats don't show up in history
+		dispatch({ type: 'AI_CHAT_OPEN', windowId, conversationId: uuid.create(), messages: [] });
 	}, [dispatch, windowId, cancelRequest]);
 
+	const handleOpenConversation = useCallback(async (conversationId: string) => {
+		if (conversationId === props.conversationId || archivingRef.current) return;
+		archivingRef.current = true;
+		cancelRequest();
+		try {
+			await CommandService.instance().executeInWindow('openAiChatConversation', { windowId, args: [conversationId] });
+		} catch (error) {
+			logger.error('Could not open chat conversation:', error);
+		} finally {
+			archivingRef.current = false;
+		}
+	}, [windowId, cancelRequest, props.conversationId]);
+
 	const handleClose = useCallback(() => {
 		void CommandService.instance().executeInWindow('toggleAiChat', { windowId: windowId, args: [] });
 	}, [windowId]);
 
+	const handleDeleteConversation = useCallback(async (conversationId: string) => {
+		if (archivingRef.current) return;
+		archivingRef.current = true;
+		if (conversationId === props.conversationId) cancelRequest();
+		try {
+			await ChatConversation.deleteConversation(conversationId);
+			setConversations(current => current.filter(item => item.id !== conversationId));
+			dispatch({ type: 'AI_CHAT_DELETE', conversationId });
+		} catch (error) {
+			logger.error('Could not delete chat conversation:', error);
+			await dialogs.alert(_('Could not delete conversation.'));
+		} finally {
+			archivingRef.current = false;
+		}
+	}, [dispatch, cancelRequest, props.conversationId]);
+
+	const handleRenameConversation = useCallback(async (conversation: Conversation, newTitle: string) => {
+		const title = newTitle.trim();
+		if (!title || title === conversation.title) return;
+		try {
+			await ChatConversation.renameConversation(conversation.id, title);
+			setConversations(current => current.map(item => item.id === conversation.id ? { ...item, title } : item));
+		} catch (error) {
+			logger.error('Could not rename chat conversation:', error);
+			await dialogs.alert(_('Could not rename conversation.'));
+		}
+	}, []);
+
 	const handleHideToolbarButton = useCallback(() => {
 		Setting.setValue('ai.chat.showToolbarButton', false);
 		handleClose();
@@ -424,24 +528,11 @@ const ChatPanel: React.FC<Props> = (props) => {
 	};
 
 	const sendButtonLabel = sending ? _('Stop generating') : _('Send');
+	const closeLabel = _('Close');
+	const newChatLabel = _('New chat');
 	const headerId = useId();
 	const { content, showingMessages } = renderContent();
 
-	const renderHeaderActions = () => {
-		if (showingMessages) {
-			return <button type='button' className='reset' onClick={handleReset}>{_('Reset')}</button>;
-		}
-
-		const closeLabel = _('Close');
-		return <button
-			type='button'
-			className='close'
-			onClick={handleClose}
-			title={closeLabel}
-			aria-label={closeLabel}
-		><i className='fas fa-times' role='img' aria-hidden={true}/></button>;
-	};
-
 	return (
 		<div
 			className='chat-panel'
@@ -452,7 +543,46 @@ const ChatPanel: React.FC<Props> = (props) => {
 		>
 			<div className='header chat-panel-header'>
 				<h1 className='title' id={headerId}>{_('AI Chat')}</h1>
-				{renderHeaderActions()}
+				{props.availabilityReason !== AvailabilityReason.Disabled && (
+					<button
+						type='button'
+						className='history toolbar-button'
+						ref={historyButtonRef}
+						onClick={handleHistoryToggle}
+						title={_('Chat history')}
+						aria-label={_('Chat history')}
+						aria-expanded={historyOpen}
+						aria-controls={historyId}
+					>
+						<i className='toolbar-icon far fa-clock' aria-hidden='true'/>
+					</button>
+				)}
+				{historyOpen && (
+					// Placed right after its button so that Tab moves from the button into the popup
+					<ChatHistory
+						conversations={conversations}
+						currentConversationId={props.conversationId}
+						id={historyId}
+						popupRef={historyPopupRef}
+						onSearchChange={loadConversationHistory}
+						onOpen={handleOpenConversation}
+						onRename={handleRenameConversation}
+						onDelete={handleDeleteConversation}
+						onClose={closeHistory}
+					/>
+				)}
+				{showingMessages && (
+					<button type='button' className='reset toolbar-button' onClick={handleNewChat} title={newChatLabel} aria-label={newChatLabel}>
+						<i className='toolbar-icon fas fa-comment-medical' aria-hidden='true'/>
+					</button>
+				)}
+				<button
+					type='button'
+					className='close toolbar-button'
+					onClick={handleClose}
+					title={closeLabel}
+					aria-label={closeLabel}
+				><i className='toolbar-icon fas fa-times' role='img' aria-hidden={true}/></button>
 			</div>
 			{content}
 		</div>
@@ -471,15 +601,19 @@ const mapStateToProps = (state: AppState, ownProps: OwnProps) => {
 	return {
 		themeId: state.settings.theme,
 		available: availability.available,
+		availabilityReason: availability.reason,
 		unavailableHint: availability.hint ?? '',
 		providerType: state.settings['ai.chat.providerType'] || 'openai-compatible',
 		noteId,
 		noteTitle: note?.title || '',
 		noteIsEncrypted: !!note?.encryption_applied,
 		messages: windowState.aiChatMessages || [],
+		conversationId: windowState.aiChatConversationId,
 		aiDegraded: !!state.aiStatus?.degraded,
 		showToolbarButton: !!state.settings['ai.chat.showToolbarButton'],
 	};
 };
 
-export default connect(mapStateToProps)(ChatPanel);
+const ConversationPanel: React.FC<Props> = props => <ChatPanel key={props.conversationId} {...props} />;
+
+export default connect(mapStateToProps)(ConversationPanel);
diff --git a/packages/app-desktop/gui/ChatPanel/style.scss b/packages/app-desktop/gui/ChatPanel/style.scss
index 4908d49827..e3dd6f1341 100644
--- a/packages/app-desktop/gui/ChatPanel/style.scss
+++ b/packages/app-desktop/gui/ChatPanel/style.scss
@@ -1,8 +1,11 @@
+@use './ChatHistory.scss';
+
 .chat-panel {
 	display: flex;
 	flex-direction: column;
 	width: 100%;
 	height: 100%;
+	overflow-y: auto;
 	box-sizing: border-box;
 	background-color: var(--joplin-background-color);
 	color: var(--joplin-color);
@@ -11,6 +14,7 @@
 }
 
 .chat-panel > .header {
+	position: relative;
 	display: flex;
 	flex-direction: row;
 	align-items: center;
@@ -26,12 +30,11 @@
 		margin: 0;
 	}
 
-	> .reset, > .close {
+	> .reset, > .close, > .history {
 		background: none;
 		border: none;
 		color: var(--joplin-color-faded);
 		cursor: pointer;
-		font-size: 0.85em;
 		padding: 2px 6px;
 
 		&:hover {
diff --git a/packages/app-desktop/gui/WindowCommandsAndDialogs/commands/index.ts b/packages/app-desktop/gui/WindowCommandsAndDialogs/commands/index.ts
index 1af1ea4ca6..1e9f061fd0 100644
--- a/packages/app-desktop/gui/WindowCommandsAndDialogs/commands/index.ts
+++ b/packages/app-desktop/gui/WindowCommandsAndDialogs/commands/index.ts
@@ -21,6 +21,7 @@ import * as newNote from './newNote';
 import * as newSubFolder from './newSubFolder';
 import * as newTodo from './newTodo';
 import * as newWhiteboard from './newWhiteboard';
+import * as openAiChatConversation from './openAiChatConversation';
 import * as openFolder from './openFolder';
 import * as openFolderDialog from './openFolderDialog';
 import * as openItem from './openItem';
@@ -80,6 +81,7 @@ const index: any[] = [
 	newSubFolder,
 	newTodo,
 	newWhiteboard,
+	openAiChatConversation,
 	openFolder,
 	openFolderDialog,
 	openItem,
diff --git a/packages/app-desktop/gui/WindowCommandsAndDialogs/commands/openAiChatConversation.ts b/packages/app-desktop/gui/WindowCommandsAndDialogs/commands/openAiChatConversation.ts
new file mode 100644
index 0000000000..69f802dde9
--- /dev/null
+++ b/packages/app-desktop/gui/WindowCommandsAndDialogs/commands/openAiChatConversation.ts
@@ -0,0 +1,17 @@
+import { CommandContext, CommandDeclaration, CommandRuntime } from '@joplin/lib/services/CommandService';
+import ChatConversation from '@joplin/lib/models/ChatConversation';
+
+export const declaration: CommandDeclaration = {
+	name: 'openAiChatConversation',
+};
+
+export const runtime = (): CommandRuntime => ({
+	execute: async (context: CommandContext, conversationId: string) => {
+		const messages = await ChatConversation.messages(conversationId);
+		context.dispatch({ type: 'AI_CHAT_OPEN', windowId: context.state.windowId, conversationId, messages });
+		context.dispatch({
+			type: 'WINDOW_LAYOUT_SET_ITEM_PROP', windowId: context.state.windowId,
+			itemKey: 'chatPanel', propName: 'visible', propValue: true,
+		});
+	},
+});
diff --git a/packages/lib/BaseModel.ts b/packages/lib/BaseModel.ts
index 0505c40f91..bb59e53165 100644
--- a/packages/lib/BaseModel.ts
+++ b/packages/lib/BaseModel.ts
@@ -28,6 +28,8 @@ export enum ModelType {
 	Command = 16,
 	NoteEmbedding = 17,
 	ConflictNoteState = 18,
+	ChatConversation = 19,
+	ChatMessage = 20,
 }
 
 export interface SearchOptions {
@@ -90,6 +92,8 @@ class BaseModel {
 		['TYPE_COMMAND', ModelType.Command],
 		['TYPE_NOTE_EMBEDDING', ModelType.NoteEmbedding],
 		['TYPE_CONFLICT_NOTE_STATE', ModelType.ConflictNoteState],
+		['TYPE_CHAT_CONVERSATION', ModelType.ChatConversation],
+		['TYPE_CHAT_MESSAGE', ModelType.ChatMessage],
 	];
 
 	private static uuidGenerator: ()=> string = uuid.create;
@@ -112,6 +116,8 @@ class BaseModel {
 	public static TYPE_COMMAND = ModelType.Command;
 	public static TYPE_NOTE_EMBEDDING = ModelType.NoteEmbedding;
 	public static TYPE_CONFLICT_NOTE_STATE = ModelType.ConflictNoteState;
+	public static TYPE_CHAT_CONVERSATION = ModelType.ChatConversation;
+	public static TYPE_CHAT_MESSAGE = ModelType.ChatMessage;
 
 	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- Set by the app to redux dispatch; per-app action types diverge so the function is typed loosely here
 	public static dispatch: Function = function() {};
diff --git a/packages/lib/models/ChatConversation.test.ts b/packages/lib/models/ChatConversation.test.ts
new file mode 100644
index 0000000000..f81d07eb4f
--- /dev/null
+++ b/packages/lib/models/ChatConversation.test.ts
@@ -0,0 +1,93 @@
+import BaseModel, { ModelType } from '../BaseModel';
+import Folder from './Folder';
+import Note from './Note';
+import { setupDatabaseAndSynchronizer, switchClient } from '../testing/test-utils';
+import ChatConversation, { ChatHistoryMessage } from './ChatConversation';
+import ChatMessage from './ChatMessage';
+import uuid from '../uuid';
+import { ChatRole, ChatStandardMessage, ChatToolMessage } from '../services/ai/types';
+
+const makeMessage = (props: Partial<ChatHistoryMessage> = {}): ChatHistoryMessage => ({
+	id: uuid.create(), createdTime: 100, role: 'user', text: 'Question', raw: [], noteId: '', noteTitle: '', ...props,
+});
+
+describe('ChatConversation', () => {
+	beforeEach(async () => {
+		await setupDatabaseAndSynchronizer(1);
+		await switchClient(1);
+		BaseModel.dispatch = jest.fn();
+	});
+
+	afterEach(() => {
+		BaseModel.dispatch = () => {};
+	});
+
+	it('should fill the conversation from the first message, save it through the message model and dispatch it', async () => {
+		const id = uuid.create();
+		const message = makeMessage();
+		await ChatConversation.addMessage(id, message);
+		const conversation = await ChatConversation.load(id);
+		expect(conversation).toMatchObject({ id, title: 'Question', created_time: 100, updated_time: 100, type_: ModelType.ChatConversation });
+		expect(await ChatMessage.load(message.id)).toMatchObject({ conversation_id: id, position: 0, created_time: 100, type_: ModelType.ChatMessage });
+		expect(BaseModel.modelNameToType('chat_message')).toBe(ModelType.ChatMessage);
+		expect(await ChatConversation.messages(id)).toEqual([{ ...message, hide: false }]);
+		expect(BaseModel.dispatch).toHaveBeenCalledWith({ type: 'AI_CHAT_APPEND', conversationId: id, message });
+	});
+
+	it('should keep messages in order and only bump updated_time for user and assistant messages', async () => {
+		const id = uuid.create();
+		const first = makeMessage({ role: 'error', text: 'Open a note to start chatting.', createdTime: 100 });
+		const second = makeMessage({ role: 'user', text: 'Hello', createdTime: 200 });
+		const third = makeMessage({ role: 'separator', text: 'Note B', createdTime: 300 });
+		await Promise.all([first, second, third].map(message => ChatConversation.addMessage(id, message)));
+		expect(await ChatConversation.load(id)).toMatchObject({ title: 'Hello', created_time: 100, updated_time: 200 });
+		expect((await ChatConversation.messages(id)).map(message => message.text)).toEqual([first.text, second.text, third.text]);
+	});
+
+	it('should rename a conversation without changing its last-message timestamp or messages', async () => {
+		const id = uuid.create();
+		const message = makeMessage();
+		await ChatConversation.addMessage(id, message);
+		await ChatConversation.renameConversation(id, 'Renamed');
+		expect(await ChatConversation.load(id)).toMatchObject({ title: 'Renamed', updated_time: 100 });
+		await ChatConversation.addMessage(id, makeMessage({ text: 'Another question', createdTime: 200 }));
+		expect(await ChatConversation.load(id)).toMatchObject({ title: 'Renamed', updated_time: 200 });
+	});
+
+	it('should remove a message and add tool results to the matching assistant message', async () => {
+		const id = uuid.create();
+		const removed = makeMessage({ createdTime: 100 });
+		const assistantTurn: ChatStandardMessage = { role: ChatRole.Assistant, content: '', toolCalls: [{ toolName: 'search', callId: 'call-1', arguments: {}, parseError: null }] };
+		const assistant = makeMessage({ role: 'assistant', text: '', raw: [assistantTurn], createdTime: 200 });
+		await ChatConversation.addMessage(id, removed);
+		await ChatConversation.addMessage(id, assistant);
+		await ChatConversation.removeMessage(id, removed.id);
+		const toolResult: ChatToolMessage = { role: ChatRole.Tool, content: 'result', toolName: 'search', toolCallId: 'call-1', isError: false, userDescription: '', isEdit: false };
+		await ChatConversation.addToolResult(id, toolResult);
+		expect(await ChatConversation.messages(id)).toEqual([{ ...assistant, hide: false, raw: [assistantTurn, toolResult] }]);
+		expect(BaseModel.dispatch).toHaveBeenCalledWith({ type: 'AI_CHAT_REMOVE', conversationId: id, id: removed.id });
+		expect(BaseModel.dispatch).toHaveBeenCalledWith({ type: 'AI_CHAT_ADD_TOOL_RESULT', conversationId: id, toolCall: toolResult });
+	});
+
+	it('should delete the conversation and its messages', async () => {
+		const id = uuid.create();
+		const kept = uuid.create();
+		await ChatConversation.addMessage(id, makeMessage());
+		await ChatConversation.addMessage(kept, makeMessage({ text: 'Keep' }));
+		await ChatConversation.deleteConversation(id);
+		expect(await ChatConversation.load(id)).toBeFalsy();
+		expect(await ChatMessage.byConversationId(id)).toEqual([]);
+		expect((await ChatConversation.history()).map(conversation => conversation.id)).toEqual([kept]);
+		expect(await ChatConversation.messages(kept)).toMatchObject([{ text: 'Keep' }]);
+	});
+
+	it('should keep saved note snapshots and separator text after the note is deleted', async () => {
+		const folder = await Folder.save({ title: 'Notebook' });
+		const note = await Note.save({ title: 'Original title', parent_id: folder.id });
+		const id = uuid.create();
+		await ChatConversation.addMessage(id, makeMessage({ role: 'separator', text: 'Note: Original title', noteId: note.id, noteTitle: note.title }));
+		await Note.delete(note.id, { toTrash: false });
+		expect(await ChatConversation.load(id)).toMatchObject({ title: '', created_time: 100, updated_time: 100 });
+		expect(await ChatConversation.messages(id)).toMatchObject([{ text: 'Note: Original title', noteId: note.id, noteTitle: 'Original title' }]);
+	});
+});
diff --git a/packages/lib/models/ChatConversation.ts b/packages/lib/models/ChatConversation.ts
new file mode 100644
index 0000000000..0fe6de8767
--- /dev/null
+++ b/packages/lib/models/ChatConversation.ts
@@ -0,0 +1,145 @@
+import { Mutex } from 'async-mutex';
+import BaseModel, { ModelType } from '../BaseModel';
+import markdownUtils from '../markdownUtils';
+import { ChatMessage as ChatTurn, ChatRole, ChatToolMessage } from '../services/ai/types';
+import ChatMessage from './ChatMessage';
+
+export interface ChatHistoryMessage {
+	id: string;
+	createdTime: number;
+	noteId: string;
+	noteTitle: string;
+	role: 'user' | 'assistant' | 'error' | 'separator';
+	text: string;
+	raw: ChatTurn[];
+	hide?: boolean;
+}
+
+interface Conversation {
+	id: string;
+	title: string;
+	updated_time: number;
+}
+
+export default class ChatConversation extends BaseModel {
+	private static messageMutex_ = new Mutex();
+
+	public static tableName() {
+		return 'chat_conversations';
+	}
+
+	public static modelType() {
+		return ModelType.ChatConversation;
+	}
+
+	public static useUuid() {
+		return true;
+	}
+
+	public static async history(search = ''): Promise<Conversation[]> {
+		const searchQuery = search.trim().toLowerCase();
+		if (!searchQuery) {
+			return this.db().selectAll<Conversation>('SELECT id, title, updated_time FROM chat_conversations ORDER BY updated_time DESC');
+		}
+
+		return this.db().selectAll<Conversation>(`
+			SELECT id, title, updated_time FROM chat_conversations
+			WHERE instr(LOWER(title), ?) > 0
+			OR EXISTS (
+				SELECT 1 FROM chat_messages
+				WHERE chat_messages.conversation_id = chat_conversations.id
+				AND instr(LOWER(chat_messages.text), ?) > 0
+			)
+			ORDER BY updated_time DESC
+		`, [searchQuery, searchQuery]);
+	}
+
+	public static async renameConversation(id: string, title: string) {
+		await this.save({ id, title }, { autoTimestamp: false });
+	}
+
+	public static async deleteConversation(id: string) {
+		await ChatMessage.deleteByConversationId(id);
+		await this.delete(id);
+	}
+
+	public static async messages(conversationId: string): Promise<ChatHistoryMessage[]> {
+		const conversation = await this.load(conversationId, { fields: ['id'] });
+		if (!conversation) throw new Error(`No such chat conversation: ${conversationId}`);
+		const rows = await ChatMessage.byConversationId(conversationId);
+		return rows.map(row => ({
+			id: row.id,
+			createdTime: row.created_time,
+			role: row.role as ChatHistoryMessage['role'],
+			text: row.text,
+			raw: JSON.parse(row.raw),
+			hide: !!row.hide,
+			noteId: row.note_id,
+			noteTitle: row.note_title,
+		}));
+	}
+
+	public static async addMessage(conversationId: string, message: ChatHistoryMessage) {
+		const release = await this.messageMutex_.acquire();
+		try {
+			await this.saveForMessage(conversationId, message);
+			await ChatMessage.save({
+				id: message.id,
+				conversation_id: conversationId,
+				role: message.role,
+				text: message.text,
+				raw: JSON.stringify(message.raw),
+				hide: message.hide ? 1 : 0,
+				position: await ChatMessage.nextPosition(conversationId),
+				created_time: message.createdTime,
+				note_id: message.noteId,
+				note_title: message.noteTitle,
+			}, { isNew: true, autoTimestamp: false });
+		} finally {
+			release();
+		}
+		this.dispatch({ type: 'AI_CHAT_APPEND', conversationId, message });
+	}
+
+	public static async removeMessage(conversationId: string, id: string) {
+		const release = await this.messageMutex_.acquire();
+		try {
+			await ChatMessage.delete(id);
+		} finally {
+			release();
+		}
+		this.dispatch({ type: 'AI_CHAT_REMOVE', conversationId, id });
+	}
+
+	public static async addToolResult(conversationId: string, toolCall: ChatToolMessage) {
+		const release = await this.messageMutex_.acquire();
+		try {
+			for (const row of await ChatMessage.byToolCallId(conversationId, toolCall.toolCallId)) {
+				const raw: ChatTurn[] = JSON.parse(row.raw);
+				const isTarget = raw.some(entry => entry.role === ChatRole.Assistant && entry.toolCalls?.some(call => call.callId === toolCall.toolCallId));
+				if (!isTarget) continue;
+				raw.push(toolCall);
+				await ChatMessage.save({ id: row.id, raw: JSON.stringify(raw) }, { autoTimestamp: false });
+				break;
+			}
+		} finally {
+			release();
+		}
+		this.dispatch({ type: 'AI_CHAT_ADD_TOOL_RESULT', conversationId, toolCall });
+	}
+
+	private static async saveForMessage(conversationId: string, message: ChatHistoryMessage) {
+		const title = message.role === 'user' ? markdownUtils.titleFromBody(message.text) : '';
+		const bumpsUpdatedTime = message.role === 'user' || message.role === 'assistant';
+		const conversation = await this.load(conversationId, { fields: ['id', 'title', 'updated_time'] });
+		if (!conversation) {
+			await this.save({ id: conversationId, title, created_time: message.createdTime, updated_time: message.createdTime }, { isNew: true, autoTimestamp: false });
+			return;
+		}
+
+		const newTitle = conversation.title || title;
+		const newUpdatedTime = bumpsUpdatedTime ? Math.max(conversation.updated_time, message.createdTime) : conversation.updated_time;
+		if (newTitle === conversation.title && newUpdatedTime === conversation.updated_time) return;
+		await this.save({ id: conversationId, title: newTitle, updated_time: newUpdatedTime }, { autoTimestamp: false });
+	}
+}
diff --git a/packages/lib/models/ChatMessage.ts b/packages/lib/models/ChatMessage.ts
new file mode 100644
index 0000000000..4b2b237d51
--- /dev/null
+++ b/packages/lib/models/ChatMessage.ts
@@ -0,0 +1,33 @@
+import BaseModel, { ModelType } from '../BaseModel';
+import { ChatMessageEntity } from '../services/database/types';
+
+export default class ChatMessage extends BaseModel {
+	public static tableName() {
+		return 'chat_messages';
+	}
+
+	public static modelType() {
+		return ModelType.ChatMessage;
+	}
+
+	public static useUuid() {
+		return true;
+	}
+
+	public static async byConversationId(conversationId: string): Promise<ChatMessageEntity[]> {
+		return this.modelSelectAll('SELECT * FROM chat_messages WHERE conversation_id = ? ORDER BY position', [conversationId]);
+	}
+
+	public static async byToolCallId(conversationId: string, toolCallId: string): Promise<ChatMessageEntity[]> {
+		return this.modelSelectAll('SELECT * FROM chat_messages WHERE conversation_id = ? AND role = ? AND instr(raw, ?) > 0 ORDER BY position', [conversationId, 'assistant', toolCallId]);
+	}
+
+	public static async nextPosition(conversationId: string) {
+		const row = await this.db().selectOne('SELECT MAX(position) AS position FROM chat_messages WHERE conversation_id = ?', [conversationId]);
+		return row.position === null ? 0 : row.position + 1;
+	}
+
+	public static async deleteByConversationId(conversationId: string) {
+		await this.batchDelete([conversationId], { idFieldName: 'conversation_id' });
+	}
+}
diff --git a/packages/lib/services/database/migrations/54.ts b/packages/lib/services/database/migrations/54.ts
new file mode 100644
index 0000000000..8f2df1be7c
--- /dev/null
+++ b/packages/lib/services/database/migrations/54.ts
@@ -0,0 +1,25 @@
+import { SqlQuery } from '../types';
+
+export default (): (SqlQuery|string)[] => {
+	return [
+		`CREATE TABLE chat_conversations (
+			id TEXT PRIMARY KEY NOT NULL,
+			title TEXT NOT NULL DEFAULT "",
+			created_time INT NOT NULL,
+			updated_time INT NOT NULL
+		)`,
+		`CREATE TABLE chat_messages (
+			id TEXT PRIMARY KEY NOT NULL,
+			conversation_id TEXT NOT NULL,
+			role TEXT NOT NULL,
+			text TEXT NOT NULL DEFAULT "",
+			raw TEXT NOT NULL DEFAULT "[]",
+			hide INT NOT NULL DEFAULT 0,
+			position INT NOT NULL,
+			created_time INT NOT NULL,
+			note_id TEXT NOT NULL DEFAULT "",
+			note_title TEXT NOT NULL DEFAULT ""
+		)`,
+		'CREATE UNIQUE INDEX chat_messages_conversation_position ON chat_messages (conversation_id, position)',
+	];
+};
diff --git a/packages/lib/services/database/migrations/index.ts b/packages/lib/services/database/migrations/index.ts
index 0f339e5382..0791dcecea 100644
--- a/packages/lib/services/database/migrations/index.ts
+++ b/packages/lib/services/database/migrations/index.ts
@@ -11,6 +11,7 @@ import migration50 from './50';
 import migration51 from './51';
 import migration52 from './52';
 import migration53 from './53';
+import migration54 from './54';
 
 import { Migration } from '../types';
 
@@ -27,6 +28,7 @@ const index: Migration[] = [
 	migration51,
 	migration52,
 	migration53,
+	migration54,
 ];
 
 export default index;
diff --git a/packages/lib/services/database/types.ts b/packages/lib/services/database/types.ts
index be53414be6..3e29738b20 100644
--- a/packages/lib/services/database/types.ts
+++ b/packages/lib/services/database/types.ts
@@ -96,6 +96,26 @@ export interface AlarmEntity {
   'trigger_time'?: number;
   'type_'?: number;
 }
+export interface ChatConversationEntity {
+  'created_time'?: number;
+  'id'?: string;
+  'title'?: string;
+  'updated_time'?: number;
+  'type_'?: number;
+}
+export interface ChatMessageEntity {
+  'conversation_id'?: string;
+  'created_time'?: number;
+  'hide'?: number;
+  'id'?: string;
+  'note_id'?: string;
+  'note_title'?: string;
+  'position'?: number;
+  'raw'?: string;
+  'role'?: string;
+  'text'?: string;
+  'type_'?: number;
+}
 export interface ConflictNoteStateEntity {
   'base_body'?: string;
   'base_title'?: string;
@@ -727,4 +747,24 @@ export const databaseSchema: DatabaseTables = {
 		remote_updated_time: { type: 'number' },
 		type_: { type: 'number' },
 	},
+	chat_conversations: {
+		created_time: { type: 'number' },
+		id: { type: 'string' },
+		title: { type: 'string' },
+		updated_time: { type: 'number' },
+		type_: { type: 'number' },
+	},
+	chat_messages: {
+		conversation_id: { type: 'string' },
+		created_time: { type: 'number' },
+		hide: { type: 'number' },
+		id: { type: 'string' },
+		note_id: { type: 'string' },
+		note_title: { type: 'string' },
+		position: { type: 'number' },
+		raw: { type: 'string' },
+		role: { type: 'string' },
+		text: { type: 'string' },
+		type_: { type: 'number' },
+	},
 };
\ No newline at end of file
diff --git a/packages/lib/testing/test-utils.ts b/packages/lib/testing/test-utils.ts
index f2378c526b..184c4df7ff 100644
--- a/packages/lib/testing/test-utils.ts
+++ b/packages/lib/testing/test-utils.ts
@@ -322,6 +322,8 @@ async function clearDatabase(id: number = null) {
 	await ItemChange.waitForAllSaved();
 
 	const tableNames = [
+		'chat_conversations',
+		'chat_messages',
 		'deleted_items',
 		'folders',
 		'item_changes',
diff --git a/packages/tools/cspell/dictionary4.txt b/packages/tools/cspell/dictionary4.txt
index f9eb0e0097..a154960848 100644
--- a/packages/tools/cspell/dictionary4.txt
+++ b/packages/tools/cspell/dictionary4.txt
@@ -365,3 +365,4 @@ timepage
 todoist
 twodo
 Gemma
+instr
diff --git a/packages/utils/time.ts b/packages/utils/time.ts
index 93b5199b1e..8b68dabebf 100644
--- a/packages/utils/time.ts
+++ b/packages/utils/time.ts
@@ -111,6 +111,17 @@ export const formatMsToRelative = (ms: number) => {
 	return d.fromNow(false);
 };
 
+export const formatMsToRelativeTime = (ms: number) => {
+	const date = dayjs(ms);
+	if (!date.isValid()) return 'Invalid date';
+
+	const elapsed = Math.max(0, Date.now() - ms);
+	if (elapsed < Minute) return `${Math.floor(elapsed / Second)}s`;
+	if (elapsed < Hour) return `${Math.floor(elapsed / Minute)}m`;
+	if (elapsed < Day) return `${Math.floor(elapsed / Hour)}h`;
+	return `${Math.floor(elapsed / Day)}d`;
+};
+
 const joplinLocaleToDayJsLocale = (locale: string) => {
 	locale = locale.toLowerCase().replace(/_/, '-');
 	if (supportedLocales[locale]) return locale;