diff --git a/lua/gemini/api.lua b/lua/gemini/api.lua
index 0de6338..f92e1c0 100644
--- a/lua/gemini/api.lua
+++ b/lua/gemini/api.lua
@@ -1,141 +1,94 @@
--- lua/gemini/api.lua
-
+local config = require("gemini.config")
+local http = require("gemini.http")
 local M = {}
 
 -- Store conversation history
 local conversation_history = {}
 
 local function get_api_key()
-	-- Check for environment variable
-	local api_key = os.getenv("GEMINI_API_KEY")
-	if api_key then
-		return api_key
-	end
-
-	-- Check for Neovim global variable
-	api_key = vim.g.gemini_api_key
-	if api_key then
-		return api_key
-	end
-
-	return nil -- API key not found
+	return vim.g.gemini_api_key or os.getenv("GEMINI_API_KEY")
 end
 
-local function make_request(prompt, context)
-	local api_key = get_api_key()
-
-	if not api_key then
-		vim.notify(
-			"Google AI API key not set. Set GEMINI_API_KEY environment variable or g.gemini_api_key in your init.vim or init.lua.",
-			vim.log.levels.ERROR
-		)
-		return nil
-	end
-
-	local model = "gemini-2.0-flash"
+local function create_contents(prompt, context)
 	local contents = {}
 	
-	-- Add conversation history to the request
 	for _, message in ipairs(conversation_history) do
 		table.insert(contents, {
 			role = message.role,
-			parts = {{
-				text = message.content
-			}}
+			parts = {{text = message.content}}
 		})
 	end
 
-	-- Add the current prompt
 	if context then
 		table.insert(contents, {
 			role = "user",
-			parts = {{
-				text = "Context:\n" .. context .. "\n\nQuery: " .. prompt
-			}}
+			parts = {{text = "Context:\n" .. context .. "\n\nQuery: " .. prompt}}
 		})
 	else
 		table.insert(contents, {
 			role = "user",
-			parts = {{
-				text = prompt
-			}}
+			parts = {{text = prompt}}
 		})
 	end
 
-	local payload = vim.json.encode({
-		contents = contents,
-	})
+	return contents
+end
 
-	-- Escape the payload for shell
-	payload = vim.fn.shellescape(payload)
+local function store_message(role, content)
+	table.insert(conversation_history, {role = role, content = content})
+end
 
-	local command = string.format(
-		"curl -s -X POST "
-			.. "'https://generativelanguage.googleapis.com/v1/models/%s:generateContent?key=%s' "
-			.. "-H 'Content-Type: application/json' "
-			.. "-d %s",
-		model,
-		api_key,
-		payload
+local function handle_response(result, callback)
+	if result.error then
+		callback(nil, "API Error: " .. vim.inspect(result.error))
+		return
+	end
+
+	if result.candidates and
+	   result.candidates[1] and
+	   result.candidates[1].content and
+	   result.candidates[1].content.parts and
+	   result.candidates[1].content.parts[1] and
+	   result.candidates[1].content.parts[1].text then
+		
+		local response_text = result.candidates[1].content.parts[1].text
+		store_message("model", response_text)
+		callback(response_text)
+	else
+		callback(nil, "Unexpected response structure")
+	end
+end
+
+function M.get_response(prompt, context, callback)
+	local api_key = get_api_key()
+	
+	if not api_key then
+		vim.schedule(function()
+			callback(nil, "API key not set")
+		end)
+		return
+	end
+
+	store_message("user", prompt)
+
+	local contents = create_contents(prompt, context)
+	local payload = vim.json.encode({contents = contents})
+	local url = string.format(
+		config.options.api_url .. "?key=%s",
+		config.options.model,
+		api_key
 	)
 
-	local result = vim.fn.system(command)
-
-	-- Check for errors during the curl execution
-	if vim.v.shell_error ~= 0 then
-		vim.notify("Error executing curl. Check your command and ensure curl is installed.", vim.log.levels.ERROR)
-		return nil
-	end
-
-	local success, decoded_result = pcall(vim.json.decode, result)
-	if not success then
-		vim.notify("Failed to decode API response: " .. result, vim.log.levels.ERROR)
-		return nil
-	end
-
-	return decoded_result
+	local request = http.Request.new(url, payload)
+	request:execute(function(result, error)
+		if error then
+			callback(nil, error)
+			return
+		end
+		handle_response(result, callback)
+	end)
 end
 
-function M.get_response(prompt, context)
-	-- Add user message to history
-	table.insert(conversation_history, {
-		role = "user",
-		content = prompt
-	})
-
-	local result = make_request(prompt, context)
-
-	if result then
-		if result.error then
-			vim.notify("API Error: " .. vim.inspect(result.error), vim.log.levels.ERROR)
-			return nil
-		end
-
-		if
-			result.candidates
-			and result.candidates[1]
-			and result.candidates[1].content
-			and result.candidates[1].content.parts
-			and result.candidates[1].content.parts[1]
-			and result.candidates[1].content.parts[1].text
-		then
-			local response_text = result.candidates[1].content.parts[1].text
-			-- Add assistant response to history
-			table.insert(conversation_history, {
-				role = "model",
-				content = response_text
-			})
-			return response_text
-		end
-		
-		vim.notify("Unexpected response structure: " .. vim.inspect(result), vim.log.levels.ERROR)
-	end
-	
-	vim.notify("No response from Google AI API or malformed response.", vim.log.levels.ERROR)
-	return nil
-end
-
--- Add function to clear conversation history
 function M.clear_conversation()
 	conversation_history = {}
 end
diff --git a/lua/gemini/chat.lua b/lua/gemini/chat.lua
new file mode 100644
index 0000000..b988541
--- /dev/null
+++ b/lua/gemini/chat.lua
@@ -0,0 +1,145 @@
+local config = require("gemini.config")
+local M = {}
+
+-- Store chat state
+local state = {
+    bufnr = nil,
+    winnr = nil,
+    current_context = nil,
+}
+
+local function setup_chat_highlighting(bufnr)
+    vim.api.nvim_buf_set_option(bufnr, 'syntax', '')
+    pcall(vim.treesitter.start, bufnr, "markdown")
+
+    vim.cmd([[
+        highlight default GeminiUser guifg=#EBCB8B gui=bold
+        highlight default GeminiSeparator guifg=#616E88 gui=bold
+        syntax match GeminiUser /^User:.*$/
+        syntax match GeminiSeparator /^━━━━━━━━━━━━━━━━━━━━━━━━━━$/
+    ]])
+end
+
+local function setup_buffer_options(bufnr)
+    local options = {
+        buftype = 'nofile',
+        filetype = 'markdown',
+        buflisted = false,
+        swapfile = false,
+        bufhidden = 'wipe',
+        modifiable = false,
+    }
+
+    for option, value in pairs(options) do
+        vim.api.nvim_buf_set_option(bufnr, option, value)
+    end
+end
+
+local function setup_buffer_autocmds(bufnr)
+    local augroup = vim.api.nvim_create_augroup('GeminiChatBuffer', { clear = true })
+    vim.api.nvim_create_autocmd({'BufReadCmd', 'FileReadCmd', 'BufWriteCmd'}, {
+        group = augroup,
+        buffer = bufnr,
+        callback = function()
+            vim.notify('File operations are not allowed in the chat window', vim.log.levels.WARN)
+            return true
+        end
+    })
+end
+
+local function setup_buffer_keymaps(bufnr)
+    local opts = { buffer = bufnr, nowait = true }
+    
+    -- Disable file operations
+    local operations = {'e', 'edit', 'w', 'write', 'sp', 'split', 'vs', 'vsplit',
+                       'new', 'vnew', 'read', 'update', 'saveas'}
+    for _, op in ipairs(operations) do
+        vim.keymap.set('n', ':' .. op, function()
+            vim.notify('Operation not allowed in chat window', vim.log.levels.WARN)
+        end, opts)
+    end
+
+    -- Disable command mode
+    vim.keymap.set('n', ':', function()
+        vim.notify('Command mode disabled in chat window', vim.log.levels.WARN)
+    end, opts)
+
+    -- Set chat-specific keymaps
+    local mappings = config.options.mappings
+    vim.keymap.set('n', mappings.close, function()
+        vim.api.nvim_win_close(state.winnr, true)
+        state.winnr = nil
+    end, opts)
+
+    vim.keymap.set('n', mappings.return_focus, function()
+        vim.cmd('wincmd p')
+    end, opts)
+
+    vim.keymap.set('n', mappings.new_query, function()
+        require("gemini").prompt_query(state.current_context)
+    end, opts)
+end
+
+function M.create_window()
+    if not state.bufnr or not vim.api.nvim_buf_is_valid(state.bufnr) then
+        state.bufnr = vim.api.nvim_create_buf(false, true)
+        setup_buffer_options(state.bufnr)
+        setup_buffer_autocmds(state.bufnr)
+        setup_buffer_keymaps(state.bufnr)
+    end
+
+    local win_opts = config.options.window
+    if not state.winnr or not vim.api.nvim_win_is_valid(state.winnr) then
+        state.winnr = vim.api.nvim_open_win(state.bufnr, true, {
+            relative = "editor",
+            width = win_opts.width(),
+            height = win_opts.height(),
+            row = 0,
+            col = vim.o.columns - win_opts.width(),
+            border = win_opts.border,
+            title = win_opts.title,
+            title_pos = win_opts.title_pos,
+            style = "minimal"
+        })
+
+        vim.api.nvim_win_set_option(state.winnr, 'wrap', true)
+        vim.api.nvim_win_set_option(state.winnr, 'linebreak', true)
+        vim.api.nvim_win_set_option(state.winnr, 'breakindent', true)
+
+        setup_chat_highlighting(state.bufnr)
+    end
+end
+
+function M.update_content(content, is_new_chat)
+    vim.api.nvim_buf_set_option(state.bufnr, 'modifiable', true)
+
+    if is_new_chat then
+        vim.api.nvim_buf_set_lines(state.bufnr, 0, -1, false, vim.split(content, "\n"))
+    else
+        local separator = "━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        vim.api.nvim_buf_set_lines(state.bufnr, -1, -1, false, {separator})
+        vim.api.nvim_buf_set_lines(state.bufnr, -1, -1, false, vim.split(content, "\n"))
+    end
+
+    vim.api.nvim_buf_set_option(state.bufnr, 'modifiable', false)
+
+    -- Scroll to show new content
+    local line_count = vim.api.nvim_buf_line_count(state.bufnr)
+    local content_lines = #vim.split(content, "\n")
+    local start_line = line_count - content_lines + 1
+    vim.api.nvim_win_set_cursor(state.winnr, {start_line, 0})
+    vim.cmd('normal! zt')
+    vim.cmd('wincmd p')
+end
+
+function M.set_context(context)
+    state.current_context = context
+end
+
+function M.clear()
+    if state.bufnr and vim.api.nvim_buf_is_valid(state.bufnr) then
+        vim.api.nvim_buf_set_lines(state.bufnr, 0, -1, false, {})
+    end
+end
+
+return M
\ No newline at end of file
diff --git a/lua/gemini/config.lua b/lua/gemini/config.lua
new file mode 100644
index 0000000..d0d1c41
--- /dev/null
+++ b/lua/gemini/config.lua
@@ -0,0 +1,30 @@
+local M = {}
+
+M.defaults = {
+    model = "gemini-2.0-flash",
+    api_url = "https://generativelanguage.googleapis.com/v1/models/%s:generateContent",
+    window = {
+        width = function() return math.floor(vim.o.columns / 3) end,
+        height = function() return vim.o.lines - 2 end,
+        border = "rounded",
+        title = "Gemini Chat Session",
+        title_pos = "center",
+    },
+    mappings = {
+        close = 'q',
+        return_focus = '<Esc>',
+        new_query = 'i',
+    },
+    highlights = {
+        user = "GeminiUser",
+        separator = "GeminiSeparator",
+    },
+}
+
+M.options = {}
+
+function M.setup(opts)
+    M.options = vim.tbl_deep_extend("force", {}, M.defaults, opts or {})
+end
+
+return M
\ No newline at end of file
diff --git a/lua/gemini/http.lua b/lua/gemini/http.lua
new file mode 100644
index 0000000..f0a4a7d
--- /dev/null
+++ b/lua/gemini/http.lua
@@ -0,0 +1,93 @@
+local M = {}
+
+-- HTTP Request class
+local Request = {}
+Request.__index = Request
+
+function Request.new(url, payload)
+    local self = setmetatable({}, Request)
+    self.url = url
+    self.payload = payload
+    self.response = ""
+    self.error_msg = ""
+    self.stdout = vim.loop.new_pipe()
+    self.stderr = vim.loop.new_pipe()
+    self.handle = nil
+    return self
+end
+
+function Request:cleanup()
+    if self.stdout then self.stdout:close() end
+    if self.stderr then self.stderr:close() end
+    if self.handle then self.handle:close() end
+end
+
+function Request:handle_error(callback, msg)
+    self:cleanup()
+    vim.schedule(function()
+        callback(nil, msg)
+    end)
+end
+
+function Request:setup_pipes(callback)
+    self.stdout:read_start(function(err, chunk)
+        if err then
+            self:handle_error(callback, "Read error: " .. err)
+            return
+        end
+        if chunk then
+            self.response = self.response .. chunk
+        end
+    end)
+
+    self.stderr:read_start(function(err, chunk)
+        if err then
+            self:handle_error(callback, "Error reading stderr: " .. err)
+            return
+        end
+        if chunk then
+            self.error_msg = self.error_msg .. chunk
+        end
+    end)
+end
+
+function Request:execute(callback)
+    self.handle = vim.loop.spawn('curl', {
+        args = {
+            '-s',
+            '-X', 'POST',
+            '-H', 'Content-Type: application/json',
+            '-d', self.payload,
+            self.url
+        },
+        stdio = {nil, self.stdout, self.stderr}
+    }, function(exit_code)
+        self:cleanup()
+
+        if exit_code ~= 0 then
+            vim.schedule(function()
+                callback(nil, "Curl failed with code " .. exit_code .. ": " .. self.error_msg)
+            end)
+            return
+        end
+
+        local success, decoded = pcall(vim.json.decode, self.response)
+        vim.schedule(function()
+            if success then
+                callback(decoded)
+            else
+                callback(nil, "JSON decode error: " .. self.response)
+            end
+        end)
+    end)
+
+    if not self.handle then
+        self:handle_error(callback, "Failed to start curl")
+        return
+    end
+
+    self:setup_pipes(callback)
+end
+
+M.Request = Request
+return M
\ No newline at end of file
diff --git a/lua/gemini/init.lua b/lua/gemini/init.lua
index 49c3446..5aa34eb 100644
--- a/lua/gemini/init.lua
+++ b/lua/gemini/init.lua
@@ -1,291 +1,84 @@
 -- lua/gemini/init.lua
 
 local api = require("gemini.api")
-local M = {}
+local chat = require("gemini.chat")
+local config = require("gemini.config")
 
--- Store the buffer number of the chat window
-local chat_bufnr = nil
-local chat_winnr = nil
-local current_context = nil  -- Store the current context
+local M = {}
 
 local function get_current_buffer_content()
     local lines = vim.api.nvim_buf_get_lines(0, 0, -1, false)
     return table.concat(lines, "\n")
 end
 
-local function setup_chat_highlighting(bufnr)
-    -- Enable treesitter for the buffer
-    vim.api.nvim_buf_set_option(bufnr, 'syntax', '')
-    local success = pcall(vim.treesitter.start, bufnr, "markdown")
-    if not success then
-        -- Fallback to basic markdown syntax if treesitter fails
-        vim.api.nvim_buf_set_option(bufnr, 'syntax', 'markdown')
-    end
-
-    -- Create syntax groups for user input and separators
-    vim.cmd([[
-        highlight GeminiUser guifg=#EBCB8B gui=bold
-        highlight GeminiSeparator guifg=#616E88 gui=bold
-        syntax match GeminiUser /^User:.*$/
-        syntax match GeminiSeparator /^━━━━━━━━━━━━━━━━━━━━━━━━━━$/ 
-    ]])
-end
-
-local function update_chat_window(new_content)
-    if not chat_bufnr or not vim.api.nvim_buf_is_valid(chat_bufnr) then
-        -- Create a new buffer for chat
-        chat_bufnr = vim.api.nvim_create_buf(false, true)
-        
-        -- Set buffer options to prevent file operations
-        vim.api.nvim_buf_set_option(chat_bufnr, 'buftype', 'nofile')
-        vim.api.nvim_buf_set_option(chat_bufnr, 'filetype', 'markdown')
-        vim.api.nvim_buf_set_option(chat_bufnr, 'buflisted', false)
-        vim.api.nvim_buf_set_option(chat_bufnr, 'swapfile', false)
-        vim.api.nvim_buf_set_option(chat_bufnr, 'bufhidden', 'wipe')
-        
-        -- Create buffer-local autocmds to prevent file operations
-        local augroup = vim.api.nvim_create_augroup('GeminiChatBuffer', { clear = true })
-        vim.api.nvim_create_autocmd({'BufReadCmd', 'FileReadCmd', 'BufWriteCmd'}, {
-            group = augroup,
-            buffer = chat_bufnr,
-            callback = function()
-                vim.notify('File operations are not allowed in the chat window', vim.log.levels.WARN)
-                return true  -- Prevent the default behavior
-            end
-        })
-
-        -- Instead of creating commands, we'll use buffer-local keymaps to disable operations
-        local operations = {
-            'e', 'edit', 'w', 'write', 'sp', 'split', 'vs', 'vsplit',
-            'new', 'vnew', 'read', 'update', 'saveas'
-        }
-        
-        for _, op in ipairs(operations) do
-            -- Disable both normal and command-line operations
-            vim.keymap.set('n', ':' .. op, function()
-                vim.notify('Operation not allowed in chat window', vim.log.levels.WARN)
-            end, { buffer = chat_bufnr, nowait = true })
+function M.prompt_query(context)
+    local prompt = context and "Gemini (with buffer context): " or "Gemini: "
+    vim.ui.input({ prompt = prompt }, function(input)
+        if input then
+            M.query(input, context)
         end
-
-        -- Disable entering command-line mode
-        vim.keymap.set('n', ':', function()
-            vim.notify('Command mode disabled in chat window', vim.log.levels.WARN)
-        end, { buffer = chat_bufnr, nowait = true })
-    end
-
-    -- Calculate dimensions
-    local width = math.floor(vim.o.columns / 3)
-    local height = vim.o.lines - 2
-
-    if not chat_winnr or not vim.api.nvim_win_is_valid(chat_winnr) then
-        -- Create the window
-        chat_winnr = vim.api.nvim_open_win(chat_bufnr, true, {
-            relative = "editor",
-            width = width,
-            height = height,
-            row = 0,
-            col = vim.o.columns - width,
-            border = "rounded",
-            title = "Gemini Chat Session",
-            title_pos = "center",
-            style = "minimal"
-        })
-
-        -- Set window-local options
-        vim.api.nvim_win_set_option(chat_winnr, 'wrap', true)
-        vim.api.nvim_win_set_option(chat_winnr, 'linebreak', true)
-        vim.api.nvim_win_set_option(chat_winnr, 'breakindent', true)
-
-        -- Setup custom highlighting
-        setup_chat_highlighting(chat_bufnr)
-
-        -- Set window-local keymaps
-        vim.keymap.set('n', 'q', function()
-            vim.api.nvim_win_close(chat_winnr, true)
-            chat_winnr = nil
-        end, { buffer = chat_bufnr, nowait = true })
-
-        -- Make Esc return focus to previous window
-        vim.keymap.set('n', '<Esc>', function()
-            vim.cmd('wincmd p')
-        end, { buffer = chat_bufnr, nowait = true })
-
-        -- Add input mapping with context awareness
-        vim.keymap.set('n', 'i', function()
-            vim.ui.input({ prompt = "Gemini: " }, function(input)
-                if input then
-                    M.gemini_query(input, current_context)
-                end
-            end)
-        end, { buffer = chat_bufnr, nowait = true })
-
-        -- Make buffer modifiable
-        vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', true)
-        
-        -- Initialize with content (without separator)
-        vim.api.nvim_buf_set_lines(chat_bufnr, 0, -1, false, vim.split(new_content, "\n"))
-        
-        -- Make buffer unmodifiable
-        vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', false)
-    else
-        -- Make buffer modifiable
-        vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', true)
-        
-        -- Add separator before new content (only for subsequent messages)
-        local separator = "━━━━━━━━━━━━━━━━━━━━━━━━━━"
-        vim.api.nvim_buf_set_lines(chat_bufnr, -1, -1, false, {separator})
-        
-        -- Update content
-        vim.api.nvim_buf_set_lines(chat_bufnr, -1, -1, false, vim.split(new_content, "\n"))
-        
-        -- Make buffer unmodifiable
-        vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', false)
-    end
-
-    -- Find the start of the current query (last line count - number of lines in new_content + 1)
-    local line_count = vim.api.nvim_buf_line_count(chat_bufnr)
-    local new_content_lines = #vim.split(new_content, "\n")
-    local query_start_line = line_count - new_content_lines + 1
-
-    -- Set cursor to the start of current query
-    vim.api.nvim_win_set_cursor(chat_winnr, {query_start_line, 0})
-
-    -- Scroll the window to show the query at the top
-    vim.cmd('normal! zt')
-
-    -- Return focus to the previous window
-    vim.cmd('wincmd p')
+    end)
 end
 
-local function gemini_query(prompt, context)
-    -- Store the context for subsequent queries
-    current_context = context
+function M.query(prompt, context)
+    chat.set_context(context)
+    chat.create_window()
     
-    -- Show initial message in chat window and ensure it's visible
     local initial_content = "User: " .. prompt .. "\n\nAssistant: Thinking..."
-    update_chat_window(initial_content)
-    
-    -- Force Neovim to update the screen
+    chat.update_content(initial_content, true)
     vim.cmd('redraw')
     
-    local response = api.get_response(prompt, context)
-    if response then
-        -- Make buffer modifiable
-        vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', true)
-        
-        -- Get all lines
-        local lines = vim.api.nvim_buf_get_lines(chat_bufnr, 0, -1, false)
-        
-        -- Find and remove the "Thinking..." line
-        for i = 1, #lines do
-            if lines[i] == "Assistant: Thinking..." then
-                -- Remove the "Thinking..." line
-                table.remove(lines, i)
-                -- Insert response lines
-                local response_lines = vim.split(response, "\n")
-                response_lines[1] = "Assistant: " .. response_lines[1]
-                for j = #response_lines, 1, -1 do
-                    table.insert(lines, i, response_lines[j])
-                end
-                break
-            end
+    api.get_response(prompt, context, function(response, error)
+        if error then
+            vim.notify("Failed to get response: " .. error, vim.log.levels.ERROR)
+            return
         end
-        
-        -- Update buffer with modified lines
-        vim.api.nvim_buf_set_lines(chat_bufnr, 0, -1, false, lines)
-        
-        -- Make buffer unmodifiable
-        vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', false)
-        
-        -- Move focus to chat window
-        if chat_winnr and vim.api.nvim_win_is_valid(chat_winnr) then
-            vim.api.nvim_set_current_win(chat_winnr)
-        end
-        
-        -- Clear the command line
-        vim.cmd('echo ""')
-    else
-        -- Replace "Thinking..." with error message
-        local lines = vim.api.nvim_buf_get_lines(chat_bufnr, 0, -1, false)
-        for i = 1, #lines do
-            if lines[i] == "Assistant: Thinking..." then
-                lines[i] = "Assistant: Failed to get response from Gemini API"
-                vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', true)
-                vim.api.nvim_buf_set_lines(chat_bufnr, 0, -1, false, lines)
-                vim.api.nvim_buf_set_option(chat_bufnr, 'modifiable', false)
-                break
-            end
-        end
-        vim.notify("Failed to get a response from Gemini API", vim.log.levels.ERROR)
-    end
+
+        local content = "User: " .. prompt .. "\n\nAssistant: " .. response
+        chat.update_content(content, true)
+    end)
 end
 
--- Make gemini_query available in M so it can be used by the setup function
-M.gemini_query = gemini_query
+function M.setup(opts)
+    -- Configure the plugin
+    config.setup(opts)
 
-function M.setup()
     -- Ensure markdown parser is installed
-    local parser_installed = pcall(vim.treesitter.language.require_language, "markdown")
-    if not parser_installed then
-        vim.notify("Installing markdown parser for treesitter...", vim.log.levels.INFO)
-        vim.fn.system({
-            "nvim",
-            "--headless",
-            "-c", "TSInstall markdown",
-            "-c", "q"
-        })
-    end
+    pcall(vim.treesitter.language.require_language, "markdown")
 
-    -- Create the user command
+    -- Create commands
     vim.api.nvim_create_user_command("Gemini", function(opts)
-        local prompt = opts.args
-        if prompt == "" then
+        if opts.args == "" then
             vim.notify("Please provide a prompt for Gemini.", vim.log.levels.WARN)
             return
         end
-        M.gemini_query(prompt)
+        M.query(opts.args)
     end, {
         desc = "Query Google AI",
         nargs = "+",
         complete = "shellcmd",
     })
 
-    -- Add command to clear chat history
     vim.api.nvim_create_user_command("GeminiClearChat", function()
         api.clear_conversation()
-        if chat_bufnr and vim.api.nvim_buf_is_valid(chat_bufnr) then
-            vim.api.nvim_buf_set_lines(chat_bufnr, 0, -1, false, {})
-        end
+        chat.clear()
         vim.notify("Chat history cleared", vim.log.levels.INFO)
     end, {
         desc = "Clear Gemini chat history"
     })
 
-    -- Set up keymapping with 'gc' for 'gemini chat'
+    -- Set up default keymaps
     vim.keymap.set("n", "<leader>gc", function()
-        vim.ui.input({ prompt = "Gemini: " }, function(input)
-            if input then
-                M.gemini_query(input)
-            end
-        end)
+        M.prompt_query()
     end, { desc = "Chat with Gemini AI" })
 
-    -- Set up keymapping with 'gs' for 'gemini sync'
     vim.keymap.set("n", "<leader>gs", function()
-        vim.ui.input({ prompt = "Gemini (with buffer context): " }, function(input)
-            if input then
-                local buffer_content = get_current_buffer_content()
-                M.gemini_query(input, buffer_content)
-            end
-        end)
+        M.prompt_query(get_current_buffer_content())
     end, { desc = "Chat with Gemini AI (with buffer context)" })
 
-    -- Set up keymapping with 'gq' for 'gemini quit/clear'
     vim.keymap.set("n", "<leader>gq", function()
         api.clear_conversation()
-        if chat_bufnr and vim.api.nvim_buf_is_valid(chat_bufnr) then
-            vim.api.nvim_buf_set_lines(chat_bufnr, 0, -1, false, {})
-        end
+        chat.clear()
         vim.notify("Chat history cleared", vim.log.levels.INFO)
     end, { desc = "Clear Gemini chat history" })
 end