1use anyhow::{Result, anyhow};
2use fs::Fs;
3use futures::{FutureExt, StreamExt, future::BoxFuture, stream::BoxStream};
4use futures::{Stream, TryFutureExt, stream};
5use gpui::{AnyView, App, AsyncApp, Context, CursorStyle, Entity, Task};
6use http_client::HttpClient;
7use language_model::{
8 ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, LanguageModel, LanguageModelCompletionError,
9 LanguageModelCompletionEvent, LanguageModelId, LanguageModelName, LanguageModelProvider,
10 LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState,
11 LanguageModelRequest, LanguageModelRequestTool, LanguageModelToolChoice, LanguageModelToolUse,
12 LanguageModelToolUseId, MessageContent, RateLimiter, Role, StopReason, TokenUsage, env_var,
13};
14use menu;
15use ollama::{
16 ChatMessage, ChatOptions, ChatRequest, ChatResponseDelta, OLLAMA_API_URL, OllamaFunctionCall,
17 OllamaFunctionTool, OllamaToolCall, get_models, show_model, stream_chat_completion,
18};
19pub use settings::OllamaAvailableModel as AvailableModel;
20use settings::{Settings, SettingsStore, update_settings_file};
21use std::pin::Pin;
22use std::sync::LazyLock;
23use std::sync::atomic::{AtomicU64, Ordering};
24use std::{collections::HashMap, sync::Arc};
25use ui::{
26 ButtonLike, ButtonLink, ConfiguredApiCard, ElevationIndex, List, ListBulletItem, Tooltip,
27 prelude::*,
28};
29use ui_input::InputField;
30
31use crate::AllLanguageModelSettings;
32
33const OLLAMA_DOWNLOAD_URL: &str = "https://ollama.com/download";
34const OLLAMA_LIBRARY_URL: &str = "https://ollama.com/library";
35const OLLAMA_SITE: &str = "https://ollama.com/";
36
37const PROVIDER_ID: LanguageModelProviderId = LanguageModelProviderId::new("ollama");
38const PROVIDER_NAME: LanguageModelProviderName = LanguageModelProviderName::new("Ollama");
39
40const API_KEY_ENV_VAR_NAME: &str = "OLLAMA_API_KEY";
41static API_KEY_ENV_VAR: LazyLock<EnvVar> = env_var!(API_KEY_ENV_VAR_NAME);
42
43#[derive(Default, Debug, Clone, PartialEq)]
44pub struct OllamaSettings {
45 pub api_url: String,
46 pub auto_discover: bool,
47 pub available_models: Vec<AvailableModel>,
48 pub context_window: Option<u64>,
49}
50
51pub struct OllamaLanguageModelProvider {
52 http_client: Arc<dyn HttpClient>,
53 state: Entity<State>,
54}
55
56pub struct State {
57 api_key_state: ApiKeyState,
58 http_client: Arc<dyn HttpClient>,
59 fetched_models: Vec<ollama::Model>,
60 fetch_model_task: Option<Task<Result<()>>>,
61}
62
63impl State {
64 fn is_authenticated(&self) -> bool {
65 !self.fetched_models.is_empty()
66 }
67
68 fn set_api_key(&mut self, api_key: Option<String>, cx: &mut Context<Self>) -> Task<Result<()>> {
69 let api_url = OllamaLanguageModelProvider::api_url(cx);
70 let task = self
71 .api_key_state
72 .store(api_url, api_key, |this| &mut this.api_key_state, cx);
73
74 self.fetched_models.clear();
75 cx.spawn(async move |this, cx| {
76 let result = task.await;
77 this.update(cx, |this, cx| this.restart_fetch_models_task(cx))
78 .ok();
79 result
80 })
81 }
82
83 fn authenticate(&mut self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> {
84 let api_url = OllamaLanguageModelProvider::api_url(cx);
85 let task = self
86 .api_key_state
87 .load_if_needed(api_url, |this| &mut this.api_key_state, cx);
88
89 // Always try to fetch models - if no API key is needed (local Ollama), it will work
90 // If API key is needed and provided, it will work
91 // If API key is needed and not provided, it will fail gracefully
92 cx.spawn(async move |this, cx| {
93 let result = task.await;
94 this.update(cx, |this, cx| this.restart_fetch_models_task(cx))
95 .ok();
96 result
97 })
98 }
99
100 fn fetch_models(&mut self, cx: &mut Context<Self>) -> Task<Result<()>> {
101 let http_client = Arc::clone(&self.http_client);
102 let api_url = OllamaLanguageModelProvider::api_url(cx);
103 let api_key = self.api_key_state.key(&api_url);
104
105 // As a proxy for the server being "authenticated", we'll check if its up by fetching the models
106 cx.spawn(async move |this, cx| {
107 let models = get_models(http_client.as_ref(), &api_url, api_key.as_deref()).await?;
108
109 let tasks = models
110 .into_iter()
111 // Since there is no metadata from the Ollama API
112 // indicating which models are embedding models,
113 // simply filter out models with "-embed" in their name
114 .filter(|model| !model.name.contains("-embed"))
115 .map(|model| {
116 let http_client = Arc::clone(&http_client);
117 let api_url = api_url.clone();
118 let api_key = api_key.clone();
119 async move {
120 let name = model.name.as_str();
121 let model =
122 show_model(http_client.as_ref(), &api_url, api_key.as_deref(), name)
123 .await?;
124 let ollama_model = ollama::Model::new(
125 name,
126 None,
127 model.context_length,
128 Some(model.supports_tools()),
129 Some(model.supports_vision()),
130 Some(model.supports_thinking()),
131 );
132 Ok(ollama_model)
133 }
134 });
135
136 // Rate-limit capability fetches
137 // since there is an arbitrary number of models available
138 let mut ollama_models: Vec<_> = futures::stream::iter(tasks)
139 .buffer_unordered(5)
140 .collect::<Vec<Result<_>>>()
141 .await
142 .into_iter()
143 .collect::<Result<Vec<_>>>()?;
144
145 ollama_models.sort_by(|a, b| a.name.cmp(&b.name));
146
147 this.update(cx, |this, cx| {
148 this.fetched_models = ollama_models;
149 cx.notify();
150 })
151 })
152 }
153
154 fn restart_fetch_models_task(&mut self, cx: &mut Context<Self>) {
155 let task = self.fetch_models(cx);
156 self.fetch_model_task.replace(task);
157 }
158}
159
160impl OllamaLanguageModelProvider {
161 pub fn new(http_client: Arc<dyn HttpClient>, cx: &mut App) -> Self {
162 let this = Self {
163 http_client: http_client.clone(),
164 state: cx.new(|cx| {
165 cx.observe_global::<SettingsStore>({
166 let mut last_settings = OllamaLanguageModelProvider::settings(cx).clone();
167 move |this: &mut State, cx| {
168 let current_settings = OllamaLanguageModelProvider::settings(cx);
169 let settings_changed = current_settings != &last_settings;
170 if settings_changed {
171 let url_changed = last_settings.api_url != current_settings.api_url;
172 last_settings = current_settings.clone();
173 if url_changed {
174 this.fetched_models.clear();
175 this.authenticate(cx).detach();
176 }
177 cx.notify();
178 }
179 }
180 })
181 .detach();
182
183 State {
184 http_client,
185 fetched_models: Default::default(),
186 fetch_model_task: None,
187 api_key_state: ApiKeyState::new(Self::api_url(cx), (*API_KEY_ENV_VAR).clone()),
188 }
189 }),
190 };
191 this
192 }
193
194 fn settings(cx: &App) -> &OllamaSettings {
195 &AllLanguageModelSettings::get_global(cx).ollama
196 }
197
198 fn api_url(cx: &App) -> SharedString {
199 let api_url = &Self::settings(cx).api_url;
200 if api_url.is_empty() {
201 OLLAMA_API_URL.into()
202 } else {
203 SharedString::new(api_url.as_str())
204 }
205 }
206
207 fn has_custom_url(cx: &App) -> bool {
208 Self::settings(cx).api_url != OLLAMA_API_URL
209 }
210}
211
212impl LanguageModelProviderState for OllamaLanguageModelProvider {
213 type ObservableEntity = State;
214
215 fn observable_entity(&self) -> Option<Entity<Self::ObservableEntity>> {
216 Some(self.state.clone())
217 }
218}
219
220impl LanguageModelProvider for OllamaLanguageModelProvider {
221 fn id(&self) -> LanguageModelProviderId {
222 PROVIDER_ID
223 }
224
225 fn name(&self) -> LanguageModelProviderName {
226 PROVIDER_NAME
227 }
228
229 fn icon(&self) -> IconOrSvg {
230 IconOrSvg::Icon(IconName::AiOllama)
231 }
232
233 fn default_model(&self, _: &App) -> Option<Arc<dyn LanguageModel>> {
234 // We shouldn't try to select default model, because it might lead to a load call for an unloaded model.
235 // In a constrained environment where user might not have enough resources it'll be a bad UX to select something
236 // to load by default.
237 None
238 }
239
240 fn default_fast_model(&self, _: &App) -> Option<Arc<dyn LanguageModel>> {
241 // See explanation for default_model.
242 None
243 }
244
245 fn provided_models(&self, cx: &App) -> Vec<Arc<dyn LanguageModel>> {
246 let mut models: HashMap<String, ollama::Model> = HashMap::new();
247 let settings = OllamaLanguageModelProvider::settings(cx);
248
249 // Add models from the Ollama API
250 for model in self.state.read(cx).fetched_models.iter() {
251 let mut model = model.clone();
252 if let Some(context_window) = settings.context_window {
253 model.max_tokens = context_window;
254 }
255 models.insert(model.name.clone(), model);
256 }
257
258 // Override with available models from settings
259 merge_settings_into_models(
260 &mut models,
261 &settings.available_models,
262 settings.context_window,
263 );
264
265 let mut models = models
266 .into_values()
267 .map(|model| {
268 Arc::new(OllamaLanguageModel {
269 id: LanguageModelId::from(model.name.clone()),
270 model,
271 http_client: self.http_client.clone(),
272 request_limiter: RateLimiter::new(4),
273 state: self.state.clone(),
274 }) as Arc<dyn LanguageModel>
275 })
276 .collect::<Vec<_>>();
277 models.sort_by_key(|model| model.name());
278 models
279 }
280
281 fn is_authenticated(&self, cx: &App) -> bool {
282 self.state.read(cx).is_authenticated()
283 }
284
285 fn authenticate(&self, cx: &mut App) -> Task<Result<(), AuthenticateError>> {
286 self.state.update(cx, |state, cx| state.authenticate(cx))
287 }
288
289 fn configuration_view(
290 &self,
291 _target_agent: language_model::ConfigurationViewTargetAgent,
292 window: &mut Window,
293 cx: &mut App,
294 ) -> AnyView {
295 let state = self.state.clone();
296 cx.new(|cx| ConfigurationView::new(state, window, cx))
297 .into()
298 }
299
300 fn reset_credentials(&self, cx: &mut App) -> Task<Result<()>> {
301 self.state
302 .update(cx, |state, cx| state.set_api_key(None, cx))
303 }
304}
305
306pub struct OllamaLanguageModel {
307 id: LanguageModelId,
308 model: ollama::Model,
309 http_client: Arc<dyn HttpClient>,
310 request_limiter: RateLimiter,
311 state: Entity<State>,
312}
313
314impl OllamaLanguageModel {
315 fn to_ollama_request(&self, request: LanguageModelRequest) -> ChatRequest {
316 let supports_vision = self.model.supports_vision.unwrap_or(false);
317
318 let mut messages = Vec::with_capacity(request.messages.len());
319
320 for mut msg in request.messages.into_iter() {
321 let images = if supports_vision {
322 msg.content
323 .iter()
324 .filter_map(|content| match content {
325 MessageContent::Image(image) => Some(image.source.to_string()),
326 _ => None,
327 })
328 .collect::<Vec<String>>()
329 } else {
330 vec![]
331 };
332
333 match msg.role {
334 Role::User => {
335 for tool_result in msg
336 .content
337 .extract_if(.., |x| matches!(x, MessageContent::ToolResult(..)))
338 {
339 match tool_result {
340 MessageContent::ToolResult(tool_result) => {
341 messages.push(ChatMessage::Tool {
342 tool_name: tool_result.tool_name.to_string(),
343 content: tool_result.content.to_str().unwrap_or("").to_string(),
344 })
345 }
346 _ => unreachable!("Only tool result should be extracted"),
347 }
348 }
349 if !msg.content.is_empty() {
350 messages.push(ChatMessage::User {
351 content: msg.string_contents(),
352 images: if images.is_empty() {
353 None
354 } else {
355 Some(images)
356 },
357 })
358 }
359 }
360 Role::Assistant => {
361 let content = msg.string_contents();
362 let mut thinking = None;
363 let mut tool_calls = Vec::new();
364 for content in msg.content.into_iter() {
365 match content {
366 MessageContent::Thinking { text, .. } if !text.is_empty() => {
367 thinking = Some(text)
368 }
369 MessageContent::ToolUse(tool_use) => {
370 tool_calls.push(OllamaToolCall {
371 id: Some(tool_use.id.to_string()),
372 function: OllamaFunctionCall {
373 name: tool_use.name.to_string(),
374 arguments: tool_use.input,
375 },
376 });
377 }
378 _ => (),
379 }
380 }
381 messages.push(ChatMessage::Assistant {
382 content,
383 tool_calls: Some(tool_calls),
384 images: if images.is_empty() {
385 None
386 } else {
387 Some(images)
388 },
389 thinking,
390 })
391 }
392 Role::System => messages.push(ChatMessage::System {
393 content: msg.string_contents(),
394 }),
395 }
396 }
397 ChatRequest {
398 model: self.model.name.clone(),
399 messages,
400 keep_alive: self.model.keep_alive.clone().unwrap_or_default(),
401 stream: true,
402 options: Some(ChatOptions {
403 num_ctx: Some(self.model.max_tokens),
404 stop: Some(request.stop),
405 temperature: request.temperature.or(Some(1.0)),
406 ..Default::default()
407 }),
408 think: self
409 .model
410 .supports_thinking
411 .map(|supports_thinking| supports_thinking && request.thinking_allowed),
412 tools: if self.model.supports_tools.unwrap_or(false) {
413 request.tools.into_iter().map(tool_into_ollama).collect()
414 } else {
415 vec![]
416 },
417 }
418 }
419}
420
421impl LanguageModel for OllamaLanguageModel {
422 fn id(&self) -> LanguageModelId {
423 self.id.clone()
424 }
425
426 fn name(&self) -> LanguageModelName {
427 LanguageModelName::from(self.model.display_name().to_string())
428 }
429
430 fn provider_id(&self) -> LanguageModelProviderId {
431 PROVIDER_ID
432 }
433
434 fn provider_name(&self) -> LanguageModelProviderName {
435 PROVIDER_NAME
436 }
437
438 fn supports_tools(&self) -> bool {
439 self.model.supports_tools.unwrap_or(false)
440 }
441
442 fn supports_images(&self) -> bool {
443 self.model.supports_vision.unwrap_or(false)
444 }
445
446 fn supports_tool_choice(&self, choice: LanguageModelToolChoice) -> bool {
447 match choice {
448 LanguageModelToolChoice::Auto => false,
449 LanguageModelToolChoice::Any => false,
450 LanguageModelToolChoice::None => false,
451 }
452 }
453
454 fn telemetry_id(&self) -> String {
455 format!("ollama/{}", self.model.id())
456 }
457
458 fn max_token_count(&self) -> u64 {
459 self.model.max_token_count()
460 }
461
462 fn count_tokens(
463 &self,
464 request: LanguageModelRequest,
465 _cx: &App,
466 ) -> BoxFuture<'static, Result<u64>> {
467 // There is no endpoint for this _yet_ in Ollama
468 // see: https://github.com/ollama/ollama/issues/1716 and https://github.com/ollama/ollama/issues/3582
469 let token_count = request
470 .messages
471 .iter()
472 .map(|msg| msg.string_contents().chars().count())
473 .sum::<usize>()
474 / 4;
475
476 async move { Ok(token_count as u64) }.boxed()
477 }
478
479 fn stream_completion(
480 &self,
481 request: LanguageModelRequest,
482 cx: &AsyncApp,
483 ) -> BoxFuture<
484 'static,
485 Result<
486 BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
487 LanguageModelCompletionError,
488 >,
489 > {
490 let request = self.to_ollama_request(request);
491
492 let http_client = self.http_client.clone();
493 let (api_key, api_url) = self.state.read_with(cx, |state, cx| {
494 let api_url = OllamaLanguageModelProvider::api_url(cx);
495 (state.api_key_state.key(&api_url), api_url)
496 });
497
498 let future = self.request_limiter.stream(async move {
499 let stream =
500 stream_chat_completion(http_client.as_ref(), &api_url, api_key.as_deref(), request)
501 .await?;
502 let stream = map_to_language_model_completion_events(stream);
503 Ok(stream)
504 });
505
506 future.map_ok(|f| f.boxed()).boxed()
507 }
508}
509
510fn map_to_language_model_completion_events(
511 stream: Pin<Box<dyn Stream<Item = anyhow::Result<ChatResponseDelta>> + Send>>,
512) -> impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
513 // Used for creating unique tool use ids
514 static TOOL_CALL_COUNTER: AtomicU64 = AtomicU64::new(0);
515
516 struct State {
517 stream: Pin<Box<dyn Stream<Item = anyhow::Result<ChatResponseDelta>> + Send>>,
518 used_tools: bool,
519 }
520
521 // We need to create a ToolUse and Stop event from a single
522 // response from the original stream
523 let stream = stream::unfold(
524 State {
525 stream,
526 used_tools: false,
527 },
528 async move |mut state| {
529 let response = state.stream.next().await?;
530
531 let delta = match response {
532 Ok(delta) => delta,
533 Err(e) => {
534 let event = Err(LanguageModelCompletionError::from(anyhow!(e)));
535 return Some((vec![event], state));
536 }
537 };
538
539 let mut events = Vec::new();
540
541 match delta.message {
542 ChatMessage::User { content, images: _ } => {
543 events.push(Ok(LanguageModelCompletionEvent::Text(content)));
544 }
545 ChatMessage::System { content } => {
546 events.push(Ok(LanguageModelCompletionEvent::Text(content)));
547 }
548 ChatMessage::Tool { content, .. } => {
549 events.push(Ok(LanguageModelCompletionEvent::Text(content)));
550 }
551 ChatMessage::Assistant {
552 content,
553 tool_calls,
554 images: _,
555 thinking,
556 } => {
557 if let Some(text) = thinking {
558 events.push(Ok(LanguageModelCompletionEvent::Thinking {
559 text,
560 signature: None,
561 }));
562 }
563
564 if let Some(tool_call) = tool_calls.and_then(|v| v.into_iter().next()) {
565 let OllamaToolCall { id, function } = tool_call;
566 let id = id.unwrap_or_else(|| {
567 format!(
568 "{}-{}",
569 &function.name,
570 TOOL_CALL_COUNTER.fetch_add(1, Ordering::Relaxed)
571 )
572 });
573 let event = LanguageModelCompletionEvent::ToolUse(LanguageModelToolUse {
574 id: LanguageModelToolUseId::from(id),
575 name: Arc::from(function.name),
576 raw_input: function.arguments.to_string(),
577 input: function.arguments,
578 is_input_complete: true,
579 thought_signature: None,
580 });
581 events.push(Ok(event));
582 state.used_tools = true;
583 } else if !content.is_empty() {
584 events.push(Ok(LanguageModelCompletionEvent::Text(content)));
585 }
586 }
587 };
588
589 if delta.done {
590 events.push(Ok(LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
591 input_tokens: delta.prompt_eval_count.unwrap_or(0),
592 output_tokens: delta.eval_count.unwrap_or(0),
593 cache_creation_input_tokens: 0,
594 cache_read_input_tokens: 0,
595 })));
596 if state.used_tools {
597 state.used_tools = false;
598 events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::ToolUse)));
599 } else {
600 events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::EndTurn)));
601 }
602 }
603
604 Some((events, state))
605 },
606 );
607
608 stream.flat_map(futures::stream::iter)
609}
610
611struct ConfigurationView {
612 api_key_editor: Entity<InputField>,
613 api_url_editor: Entity<InputField>,
614 context_window_editor: Entity<InputField>,
615 state: Entity<State>,
616}
617
618impl ConfigurationView {
619 pub fn new(state: Entity<State>, window: &mut Window, cx: &mut Context<Self>) -> Self {
620 let api_key_editor = cx.new(|cx| InputField::new(window, cx, "63e02e...").label("API key"));
621
622 let api_url_editor = cx.new(|cx| {
623 let input = InputField::new(window, cx, OLLAMA_API_URL).label("API URL");
624 input.set_text(&OllamaLanguageModelProvider::api_url(cx), window, cx);
625 input
626 });
627
628 let context_window_editor = cx.new(|cx| {
629 let input = InputField::new(window, cx, "8192").label("Context Window");
630 if let Some(context_window) = OllamaLanguageModelProvider::settings(cx).context_window {
631 input.set_text(&context_window.to_string(), window, cx);
632 }
633 input
634 });
635
636 cx.observe(&state, |_, _, cx| {
637 cx.notify();
638 })
639 .detach();
640
641 Self {
642 api_key_editor,
643 api_url_editor,
644 context_window_editor,
645 state,
646 }
647 }
648
649 fn retry_connection(&mut self, window: &mut Window, cx: &mut Context<Self>) {
650 let has_api_url = OllamaLanguageModelProvider::has_custom_url(cx);
651 let has_api_key = self
652 .state
653 .read_with(cx, |state, _| state.api_key_state.has_key());
654 if !has_api_url {
655 self.save_api_url(cx);
656 }
657 if !has_api_key {
658 self.save_api_key(&Default::default(), window, cx);
659 }
660
661 self.state.update(cx, |state, cx| {
662 state.restart_fetch_models_task(cx);
663 });
664 }
665
666 fn save_api_key(&mut self, _: &menu::Confirm, window: &mut Window, cx: &mut Context<Self>) {
667 let api_key = self.api_key_editor.read(cx).text(cx).trim().to_string();
668 if api_key.is_empty() {
669 return;
670 }
671
672 // url changes can cause the editor to be displayed again
673 self.api_key_editor
674 .update(cx, |input, cx| input.set_text("", window, cx));
675
676 let state = self.state.clone();
677 cx.spawn_in(window, async move |_, cx| {
678 state
679 .update(cx, |state, cx| state.set_api_key(Some(api_key), cx))
680 .await
681 })
682 .detach_and_log_err(cx);
683 }
684
685 fn reset_api_key(&mut self, window: &mut Window, cx: &mut Context<Self>) {
686 self.api_key_editor
687 .update(cx, |input, cx| input.set_text("", window, cx));
688
689 let state = self.state.clone();
690 cx.spawn_in(window, async move |_, cx| {
691 state
692 .update(cx, |state, cx| state.set_api_key(None, cx))
693 .await
694 })
695 .detach_and_log_err(cx);
696
697 cx.notify();
698 }
699
700 fn save_api_url(&self, cx: &mut Context<Self>) {
701 let api_url = self.api_url_editor.read(cx).text(cx).trim().to_string();
702 let current_url = OllamaLanguageModelProvider::api_url(cx);
703 if !api_url.is_empty() && &api_url != ¤t_url {
704 let fs = <dyn Fs>::global(cx);
705 update_settings_file(fs, cx, move |settings, _| {
706 settings
707 .language_models
708 .get_or_insert_default()
709 .ollama
710 .get_or_insert_default()
711 .api_url = Some(api_url);
712 });
713 }
714 }
715
716 fn reset_api_url(&mut self, window: &mut Window, cx: &mut Context<Self>) {
717 self.api_url_editor
718 .update(cx, |input, cx| input.set_text("", window, cx));
719 let fs = <dyn Fs>::global(cx);
720 update_settings_file(fs, cx, |settings, _cx| {
721 if let Some(settings) = settings
722 .language_models
723 .as_mut()
724 .and_then(|models| models.ollama.as_mut())
725 {
726 settings.api_url = Some(OLLAMA_API_URL.into());
727 }
728 });
729 cx.notify();
730 }
731
732 fn save_context_window(&mut self, cx: &mut Context<Self>) {
733 let context_window_str = self
734 .context_window_editor
735 .read(cx)
736 .text(cx)
737 .trim()
738 .to_string();
739 let current_context_window = OllamaLanguageModelProvider::settings(cx).context_window;
740
741 if let Ok(context_window) = context_window_str.parse::<u64>() {
742 if Some(context_window) != current_context_window {
743 let fs = <dyn Fs>::global(cx);
744 update_settings_file(fs, cx, move |settings, _| {
745 settings
746 .language_models
747 .get_or_insert_default()
748 .ollama
749 .get_or_insert_default()
750 .context_window = Some(context_window);
751 });
752 }
753 } else if context_window_str.is_empty() && current_context_window.is_some() {
754 let fs = <dyn Fs>::global(cx);
755 update_settings_file(fs, cx, move |settings, _| {
756 settings
757 .language_models
758 .get_or_insert_default()
759 .ollama
760 .get_or_insert_default()
761 .context_window = None;
762 });
763 }
764 }
765
766 fn reset_context_window(&mut self, window: &mut Window, cx: &mut Context<Self>) {
767 self.context_window_editor
768 .update(cx, |input, cx| input.set_text("", window, cx));
769 let fs = <dyn Fs>::global(cx);
770 update_settings_file(fs, cx, |settings, _cx| {
771 if let Some(settings) = settings
772 .language_models
773 .as_mut()
774 .and_then(|models| models.ollama.as_mut())
775 {
776 settings.context_window = None;
777 }
778 });
779 cx.notify();
780 }
781
782 fn render_instructions(cx: &App) -> Div {
783 v_flex()
784 .gap_2()
785 .child(Label::new(
786 "Run LLMs locally on your machine with Ollama, or connect to an Ollama server. \
787 Can provide access to Llama, Mistral, Gemma, and hundreds of other models.",
788 ))
789 .child(Label::new("To use local Ollama:"))
790 .child(
791 List::new()
792 .child(
793 ListBulletItem::new("")
794 .child(Label::new("Download and install Ollama from"))
795 .child(ButtonLink::new("ollama.com", "https://ollama.com/download")),
796 )
797 .child(
798 ListBulletItem::new("")
799 .child(Label::new("Start Ollama and download a model:"))
800 .child(Label::new("ollama run gpt-oss:20b").inline_code(cx)),
801 )
802 .child(ListBulletItem::new(
803 "Click 'Connect' below to start using Ollama in Zed",
804 )),
805 )
806 .child(Label::new(
807 "Alternatively, you can connect to an Ollama server by specifying its \
808 URL and API key (may not be required):",
809 ))
810 }
811
812 fn render_api_key_editor(&self, cx: &Context<Self>) -> impl IntoElement {
813 let state = self.state.read(cx);
814 let env_var_set = state.api_key_state.is_from_env_var();
815 let configured_card_label = if env_var_set {
816 format!("API key set in {API_KEY_ENV_VAR_NAME} environment variable.")
817 } else {
818 "API key configured".to_string()
819 };
820
821 if !state.api_key_state.has_key() {
822 v_flex()
823 .on_action(cx.listener(Self::save_api_key))
824 .child(self.api_key_editor.clone())
825 .child(
826 Label::new(
827 format!("You can also set the {API_KEY_ENV_VAR_NAME} environment variable and restart Zed.")
828 )
829 .size(LabelSize::Small)
830 .color(Color::Muted),
831 )
832 .into_any_element()
833 } else {
834 ConfiguredApiCard::new(configured_card_label)
835 .disabled(env_var_set)
836 .on_click(cx.listener(|this, _, window, cx| this.reset_api_key(window, cx)))
837 .when(env_var_set, |this| {
838 this.tooltip_label(format!("To reset your API key, unset the {API_KEY_ENV_VAR_NAME} environment variable."))
839 })
840 .into_any_element()
841 }
842 }
843
844 fn render_context_window_editor(&self, cx: &Context<Self>) -> Div {
845 let settings = OllamaLanguageModelProvider::settings(cx);
846 let custom_context_window_set = settings.context_window.is_some();
847
848 if custom_context_window_set {
849 h_flex()
850 .p_3()
851 .justify_between()
852 .rounded_md()
853 .border_1()
854 .border_color(cx.theme().colors().border)
855 .bg(cx.theme().colors().elevated_surface_background)
856 .child(
857 h_flex()
858 .gap_2()
859 .child(Icon::new(IconName::Check).color(Color::Success))
860 .child(v_flex().gap_1().child(Label::new(format!(
861 "Context Window: {}",
862 settings.context_window.unwrap()
863 )))),
864 )
865 .child(
866 Button::new("reset-context-window", "Reset")
867 .label_size(LabelSize::Small)
868 .icon(IconName::Undo)
869 .icon_size(IconSize::Small)
870 .icon_position(IconPosition::Start)
871 .layer(ElevationIndex::ModalSurface)
872 .on_click(
873 cx.listener(|this, _, window, cx| {
874 this.reset_context_window(window, cx)
875 }),
876 ),
877 )
878 } else {
879 v_flex()
880 .on_action(
881 cx.listener(|this, _: &menu::Confirm, _window, cx| {
882 this.save_context_window(cx)
883 }),
884 )
885 .child(self.context_window_editor.clone())
886 .child(
887 Label::new("Default: Model specific")
888 .size(LabelSize::Small)
889 .color(Color::Muted),
890 )
891 }
892 }
893
894 fn render_api_url_editor(&self, cx: &Context<Self>) -> Div {
895 let api_url = OllamaLanguageModelProvider::api_url(cx);
896 let custom_api_url_set = api_url != OLLAMA_API_URL;
897
898 if custom_api_url_set {
899 h_flex()
900 .p_3()
901 .justify_between()
902 .rounded_md()
903 .border_1()
904 .border_color(cx.theme().colors().border)
905 .bg(cx.theme().colors().elevated_surface_background)
906 .child(
907 h_flex()
908 .gap_2()
909 .child(Icon::new(IconName::Check).color(Color::Success))
910 .child(v_flex().gap_1().child(Label::new(api_url))),
911 )
912 .child(
913 Button::new("reset-api-url", "Reset API URL")
914 .label_size(LabelSize::Small)
915 .icon(IconName::Undo)
916 .icon_size(IconSize::Small)
917 .icon_position(IconPosition::Start)
918 .layer(ElevationIndex::ModalSurface)
919 .on_click(
920 cx.listener(|this, _, window, cx| this.reset_api_url(window, cx)),
921 ),
922 )
923 } else {
924 v_flex()
925 .on_action(cx.listener(|this, _: &menu::Confirm, _window, cx| {
926 this.save_api_url(cx);
927 cx.notify();
928 }))
929 .gap_2()
930 .child(self.api_url_editor.clone())
931 }
932 }
933}
934
935impl Render for ConfigurationView {
936 fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
937 let is_authenticated = self.state.read(cx).is_authenticated();
938
939 v_flex()
940 .gap_2()
941 .child(Self::render_instructions(cx))
942 .child(self.render_api_url_editor(cx))
943 .child(self.render_context_window_editor(cx))
944 .child(self.render_api_key_editor(cx))
945 .child(
946 h_flex()
947 .w_full()
948 .justify_between()
949 .gap_2()
950 .child(
951 h_flex()
952 .w_full()
953 .gap_2()
954 .map(|this| {
955 if is_authenticated {
956 this.child(
957 Button::new("ollama-site", "Ollama")
958 .style(ButtonStyle::Subtle)
959 .icon(IconName::ArrowUpRight)
960 .icon_size(IconSize::XSmall)
961 .icon_color(Color::Muted)
962 .on_click(move |_, _, cx| cx.open_url(OLLAMA_SITE))
963 .into_any_element(),
964 )
965 } else {
966 this.child(
967 Button::new("download_ollama_button", "Download Ollama")
968 .style(ButtonStyle::Subtle)
969 .icon(IconName::ArrowUpRight)
970 .icon_size(IconSize::XSmall)
971 .icon_color(Color::Muted)
972 .on_click(move |_, _, cx| {
973 cx.open_url(OLLAMA_DOWNLOAD_URL)
974 })
975 .into_any_element(),
976 )
977 }
978 })
979 .child(
980 Button::new("view-models", "View All Models")
981 .style(ButtonStyle::Subtle)
982 .icon(IconName::ArrowUpRight)
983 .icon_size(IconSize::XSmall)
984 .icon_color(Color::Muted)
985 .on_click(move |_, _, cx| cx.open_url(OLLAMA_LIBRARY_URL)),
986 ),
987 )
988 .map(|this| {
989 if is_authenticated {
990 this.child(
991 ButtonLike::new("connected")
992 .disabled(true)
993 .cursor_style(CursorStyle::Arrow)
994 .child(
995 h_flex()
996 .gap_2()
997 .child(Icon::new(IconName::Check).color(Color::Success))
998 .child(Label::new("Connected"))
999 .into_any_element(),
1000 )
1001 .child(
1002 IconButton::new("refresh-models", IconName::RotateCcw)
1003 .tooltip(Tooltip::text("Refresh Models"))
1004 .on_click(cx.listener(|this, _, window, cx| {
1005 this.state.update(cx, |state, _| {
1006 state.fetched_models.clear();
1007 });
1008 this.retry_connection(window, cx);
1009 })),
1010 ),
1011 )
1012 } else {
1013 this.child(
1014 Button::new("retry_ollama_models", "Connect")
1015 .icon_position(IconPosition::Start)
1016 .icon_size(IconSize::XSmall)
1017 .icon(IconName::PlayOutlined)
1018 .on_click(cx.listener(move |this, _, window, cx| {
1019 this.retry_connection(window, cx)
1020 })),
1021 )
1022 }
1023 }),
1024 )
1025 }
1026}
1027
1028fn merge_settings_into_models(
1029 models: &mut HashMap<String, ollama::Model>,
1030 available_models: &[AvailableModel],
1031 context_window: Option<u64>,
1032) {
1033 for setting_model in available_models {
1034 if let Some(model) = models.get_mut(&setting_model.name) {
1035 if context_window.is_none() {
1036 model.max_tokens = setting_model.max_tokens;
1037 }
1038 model.display_name = setting_model.display_name.clone();
1039 model.keep_alive = setting_model.keep_alive.clone();
1040 model.supports_tools = setting_model.supports_tools;
1041 model.supports_vision = setting_model.supports_images;
1042 model.supports_thinking = setting_model.supports_thinking;
1043 } else {
1044 models.insert(
1045 setting_model.name.clone(),
1046 ollama::Model {
1047 name: setting_model.name.clone(),
1048 display_name: setting_model.display_name.clone(),
1049 max_tokens: context_window.unwrap_or(setting_model.max_tokens),
1050 keep_alive: setting_model.keep_alive.clone(),
1051 supports_tools: setting_model.supports_tools,
1052 supports_vision: setting_model.supports_images,
1053 supports_thinking: setting_model.supports_thinking,
1054 },
1055 );
1056 }
1057 }
1058}
1059
1060fn tool_into_ollama(tool: LanguageModelRequestTool) -> ollama::OllamaTool {
1061 ollama::OllamaTool::Function {
1062 function: OllamaFunctionTool {
1063 name: tool.name,
1064 description: Some(tool.description),
1065 parameters: Some(tool.input_schema),
1066 },
1067 }
1068}
1069
1070#[cfg(test)]
1071mod tests {
1072 use super::*;
1073
1074 #[test]
1075 fn test_merge_settings_preserves_display_names_for_similar_models() {
1076 // Regression test for https://github.com/zed-industries/zed/issues/43646
1077 // When multiple models share the same base name (e.g., qwen2.5-coder:1.5b and qwen2.5-coder:3b),
1078 // each model should get its own display_name from settings, not a random one.
1079
1080 let mut models: HashMap<String, ollama::Model> = HashMap::new();
1081 models.insert(
1082 "qwen2.5-coder:1.5b".to_string(),
1083 ollama::Model {
1084 name: "qwen2.5-coder:1.5b".to_string(),
1085 display_name: None,
1086 max_tokens: 4096,
1087 keep_alive: None,
1088 supports_tools: None,
1089 supports_vision: None,
1090 supports_thinking: None,
1091 },
1092 );
1093 models.insert(
1094 "qwen2.5-coder:3b".to_string(),
1095 ollama::Model {
1096 name: "qwen2.5-coder:3b".to_string(),
1097 display_name: None,
1098 max_tokens: 4096,
1099 keep_alive: None,
1100 supports_tools: None,
1101 supports_vision: None,
1102 supports_thinking: None,
1103 },
1104 );
1105
1106 let available_models = vec![
1107 AvailableModel {
1108 name: "qwen2.5-coder:1.5b".to_string(),
1109 display_name: Some("QWEN2.5 Coder 1.5B".to_string()),
1110 max_tokens: 5000,
1111 keep_alive: None,
1112 supports_tools: Some(true),
1113 supports_images: None,
1114 supports_thinking: None,
1115 },
1116 AvailableModel {
1117 name: "qwen2.5-coder:3b".to_string(),
1118 display_name: Some("QWEN2.5 Coder 3B".to_string()),
1119 max_tokens: 6000,
1120 keep_alive: None,
1121 supports_tools: Some(true),
1122 supports_images: None,
1123 supports_thinking: None,
1124 },
1125 ];
1126
1127 merge_settings_into_models(&mut models, &available_models, None);
1128
1129 let model_1_5b = models
1130 .get("qwen2.5-coder:1.5b")
1131 .expect("1.5b model missing");
1132 let model_3b = models.get("qwen2.5-coder:3b").expect("3b model missing");
1133
1134 assert_eq!(
1135 model_1_5b.display_name,
1136 Some("QWEN2.5 Coder 1.5B".to_string()),
1137 "1.5b model should have its own display_name"
1138 );
1139 assert_eq!(model_1_5b.max_tokens, 5000);
1140
1141 assert_eq!(
1142 model_3b.display_name,
1143 Some("QWEN2.5 Coder 3B".to_string()),
1144 "3b model should have its own display_name"
1145 );
1146 assert_eq!(model_3b.max_tokens, 6000);
1147 }
1148}