The agent engineering platform.
Python agentsaiai-agentsanthropicchatgptdeepagentsenterpriseframeworkgeminigenerative-ailangchainlanggraphllmmultiagentopen-sourceopenaipydanticpythonragtypescript
feat(ollama): add basic auth support (#32328)
Mason Daughertya89c549cb086
diff --git a/libs/partners/ollama/langchain_ollama/_utils.py b/libs/partners/ollama/langchain_ollama/_utils.pyindex 8d08ed87a4..45e85e9932 100644--- a/libs/partners/ollama/langchain_ollama/_utils.py+++ b/libs/partners/ollama/langchain_ollama/_utils.py@@ -1,5 +1,11 @@"""Utility function to validate Ollama models."""+from __future__ import annotations++import base64+from typing import Optional+from urllib.parse import unquote, urlparse+from httpx import ConnectErrorfrom ollama import Client, ResponseError@@ -40,3 +46,70 @@ def validate_model(client: Client, model_name: str) -> None:"Please check your Ollama server logs.")raise ValueError(msg) from e+++def parse_url_with_auth(+ url: Optional[str],+) -> tuple[Optional[str], Optional[dict[str, str]]]:+ """Parse URL and extract `userinfo` credentials for headers.++ Handles URLs of the form: `https://user:password@host:port/path`++ Args:+ url: The URL to parse.++ Returns:+ A tuple of ``(cleaned_url, headers_dict)`` where:+ - ``cleaned_url`` is the URL without authentication credentials if any were+ found. Otherwise, returns the original URL.+ - ``headers_dict`` contains Authorization header if credentials were found.+ """+ if not url:+ return None, None++ parsed = urlparse(url)+ if not parsed.scheme or not parsed.netloc or not parsed.hostname:+ return None, None+ if not parsed.username:+ return url, None++ # Handle case where password might be empty string or None+ password = parsed.password or ""++ # Create basic auth header (decode percent-encoding)+ username = unquote(parsed.username)+ password = unquote(password)+ credentials = f"{username}:{password}"+ encoded_credentials = base64.b64encode(credentials.encode()).decode()+ headers = {"Authorization": f"Basic {encoded_credentials}"}++ # Strip credentials from URL+ cleaned_netloc = parsed.hostname or ""+ if parsed.port:+ cleaned_netloc += f":{parsed.port}"++ cleaned_url = f"{parsed.scheme}://{cleaned_netloc}"+ if parsed.path:+ cleaned_url += parsed.path+ if parsed.query:+ cleaned_url += f"?{parsed.query}"+ if parsed.fragment:+ cleaned_url += f"#{parsed.fragment}"++ return cleaned_url, headers+++def merge_auth_headers(+ client_kwargs: dict,+ auth_headers: Optional[dict[str, str]],+) -> None:+ """Merge authentication headers into client kwargs in-place.++ Args:+ client_kwargs: The client kwargs dict to update.+ auth_headers: Headers to merge (typically from ``parse_url_with_auth``).+ """+ if auth_headers:+ headers = client_kwargs.get("headers", {})+ headers.update(auth_headers)+ client_kwargs["headers"] = headersdiff --git a/libs/partners/ollama/langchain_ollama/chat_models.py b/libs/partners/ollama/langchain_ollama/chat_models.pyindex 6d7dc66373..aebc70b7f3 100644--- a/libs/partners/ollama/langchain_ollama/chat_models.py+++ b/libs/partners/ollama/langchain_ollama/chat_models.py@@ -7,19 +7,10 @@ import jsonimport loggingfrom collections.abc import AsyncIterator, Iterator, Mapping, Sequencefrom operator import itemgetter-from typing import (- Any,- Callable,- Literal,- Optional,- Union,- cast,-)+from typing import Any, Callable, Literal, Optional, Union, castfrom uuid import uuid4-from langchain_core.callbacks import (- CallbackManagerForLLMRun,-)+from langchain_core.callbacks import CallbackManagerForLLMRunfrom langchain_core.callbacks.manager import AsyncCallbackManagerForLLMRunfrom langchain_core.exceptions import OutputParserExceptionfrom langchain_core.language_models import LanguageModelInput@@ -57,7 +48,7 @@ from pydantic.json_schema import JsonSchemaValuefrom pydantic.v1 import BaseModel as BaseModelV1from typing_extensions import Self, is_typeddict-from ._utils import validate_model+from ._utils import merge_auth_headers, parse_url_with_auth, validate_modellog = logging.getLogger(__name__)@@ -592,32 +583,50 @@ class ChatOllama(BaseChatModel):"""How long the model will stay loaded into memory."""base_url: Optional[str] = None- """Base url the model is hosted under."""+ """Base url the model is hosted under.++ If none, defaults to the Ollama client default.++ Supports `userinfo` auth in the format `http://username:password@localhost:11434`.+ Useful if your Ollama server is behind a proxy.++ !!! warning+ `userinfo` is not secure and should only be used for local testing or+ in secure environments. Avoid using it in production or over unsecured+ networks.++ !!! note+ If using `userinfo`, ensure that the Ollama server is configured to+ accept and validate these credentials.++ !!! note+ `userinfo` headers are passed to both sync and async clients.++ """client_kwargs: Optional[dict] = {}- """Additional kwargs to pass to the httpx clients.+ """Additional kwargs to pass to the httpx clients. Pass headers in here.These arguments are passed to both synchronous and async clients.Use ``sync_client_kwargs`` and ``async_client_kwargs`` to pass different argumentsto synchronous and asynchronous clients.-"""async_client_kwargs: Optional[dict] = {}- """Additional kwargs to merge with ``client_kwargs`` before- passing to the httpx AsyncClient.+ """Additional kwargs to merge with ``client_kwargs`` before passing to httpx client.- `Full list of params. <https://www.python-httpx.org/api/#asyncclient>`__+ These are clients unique to the async client; for shared args use ``client_kwargs``.+ For a full list of the params, see the `httpx documentation <https://www.python-httpx.org/api/#asyncclient>`__."""sync_client_kwargs: Optional[dict] = {}- """Additional kwargs to merge with ``client_kwargs`` before- passing to the httpx Client.+ """Additional kwargs to merge with ``client_kwargs`` before passing to httpx client.- `Full list of params. <https://www.python-httpx.org/api/#client>`__+ These are clients unique to the sync client; for shared args use ``client_kwargs``.+ For a full list of the params, see the `httpx documentation <https://www.python-httpx.org/api/#client>`__."""_client: Client = PrivateAttr()@@ -682,6 +691,9 @@ class ChatOllama(BaseChatModel):"""Set clients to use for ollama."""client_kwargs = self.client_kwargs or {}+ cleaned_url, auth_headers = parse_url_with_auth(self.base_url)+ merge_auth_headers(client_kwargs, auth_headers)+sync_client_kwargs = client_kwargsif self.sync_client_kwargs:sync_client_kwargs = {**sync_client_kwargs, **self.sync_client_kwargs}@@ -690,8 +702,8 @@ class ChatOllama(BaseChatModel):if self.async_client_kwargs:async_client_kwargs = {**async_client_kwargs, **self.async_client_kwargs}- self._client = Client(host=self.base_url, **sync_client_kwargs)- self._async_client = AsyncClient(host=self.base_url, **async_client_kwargs)+ self._client = Client(host=cleaned_url, **sync_client_kwargs)+ self._async_client = AsyncClient(host=cleaned_url, **async_client_kwargs)if self.validate_model_on_init:validate_model(self._client, self.model)return selfdiff --git a/libs/partners/ollama/langchain_ollama/embeddings.py b/libs/partners/ollama/langchain_ollama/embeddings.pyindex 97f49818f0..8cdf3a6e16 100644--- a/libs/partners/ollama/langchain_ollama/embeddings.py+++ b/libs/partners/ollama/langchain_ollama/embeddings.py@@ -6,15 +6,10 @@ from typing import Any, Optionalfrom langchain_core.embeddings import Embeddingsfrom ollama import AsyncClient, Client-from pydantic import (- BaseModel,- ConfigDict,- PrivateAttr,- model_validator,-)+from pydantic import BaseModel, ConfigDict, PrivateAttr, model_validatorfrom typing_extensions import Self-from ._utils import validate_model+from ._utils import merge_auth_headers, parse_url_with_auth, validate_modelclass OllamaEmbeddings(BaseModel, Embeddings):@@ -134,32 +129,50 @@ class OllamaEmbeddings(BaseModel, Embeddings):"""base_url: Optional[str] = None- """Base url the model is hosted under."""+ """Base url the model is hosted under.++ If none, defaults to the Ollama client default.++ Supports `userinfo` auth in the format `http://username:password@localhost:11434`.+ Useful if your Ollama server is behind a proxy.++ !!! warning+ `userinfo` is not secure and should only be used for local testing or+ in secure environments. Avoid using it in production or over unsecured+ networks.++ !!! note+ If using `userinfo`, ensure that the Ollama server is configured to+ accept and validate these credentials.++ !!! note+ `userinfo` headers are passed to both sync and async clients.++ """client_kwargs: Optional[dict] = {}- """Additional kwargs to pass to the httpx clients.+ """Additional kwargs to pass to the httpx clients. Pass headers in here.These arguments are passed to both synchronous and async clients.Use ``sync_client_kwargs`` and ``async_client_kwargs`` to pass different argumentsto synchronous and asynchronous clients.-"""async_client_kwargs: Optional[dict] = {}- """Additional kwargs to merge with ``client_kwargs`` before passing to the httpx- AsyncClient.+ """Additional kwargs to merge with ``client_kwargs`` before passing to httpx client.- For a full list of the params, see the `HTTPX documentation <https://www.python-httpx.org/api/#asyncclient>`__.+ These are clients unique to the async client; for shared args use ``client_kwargs``.+ For a full list of the params, see the `httpx documentation <https://www.python-httpx.org/api/#asyncclient>`__."""sync_client_kwargs: Optional[dict] = {}- """Additional kwargs to merge with ``client_kwargs`` before- passing to the HTTPX Client.+ """Additional kwargs to merge with ``client_kwargs`` before passing to httpx client.- For a full list of the params, see the `HTTPX documentation <https://www.python-httpx.org/api/#client>`__.+ These are clients unique to the sync client; for shared args use ``client_kwargs``.+ For a full list of the params, see the `httpx documentation <https://www.python-httpx.org/api/#client>`__."""_client: Optional[Client] = PrivateAttr(default=None)@@ -261,6 +274,9 @@ class OllamaEmbeddings(BaseModel, Embeddings):"""Set clients to use for Ollama."""client_kwargs = self.client_kwargs or {}+ cleaned_url, auth_headers = parse_url_with_auth(self.base_url)+ merge_auth_headers(client_kwargs, auth_headers)+sync_client_kwargs = client_kwargsif self.sync_client_kwargs:sync_client_kwargs = {**sync_client_kwargs, **self.sync_client_kwargs}@@ -269,8 +285,8 @@ class OllamaEmbeddings(BaseModel, Embeddings):if self.async_client_kwargs:async_client_kwargs = {**async_client_kwargs, **self.async_client_kwargs}- self._client = Client(host=self.base_url, **sync_client_kwargs)- self._async_client = AsyncClient(host=self.base_url, **async_client_kwargs)+ self._client = Client(host=cleaned_url, **sync_client_kwargs)+ self._async_client = AsyncClient(host=cleaned_url, **async_client_kwargs)if self.validate_model_on_init:validate_model(self._client, self.model)return selfdiff --git a/libs/partners/ollama/langchain_ollama/llms.py b/libs/partners/ollama/langchain_ollama/llms.pyindex 7787d86da4..06f91502ba 100644--- a/libs/partners/ollama/langchain_ollama/llms.py+++ b/libs/partners/ollama/langchain_ollama/llms.py@@ -3,12 +3,7 @@from __future__ import annotationsfrom collections.abc import AsyncIterator, Iterator, Mapping-from typing import (- Any,- Literal,- Optional,- Union,-)+from typing import Any, Literal, Optional, Unionfrom langchain_core.callbacks import (AsyncCallbackManagerForLLMRun,@@ -20,7 +15,7 @@ from ollama import AsyncClient, Client, Optionsfrom pydantic import PrivateAttr, model_validatorfrom typing_extensions import Self-from ._utils import validate_model+from ._utils import merge_auth_headers, parse_url_with_auth, validate_modelclass OllamaLLM(BaseLLM):@@ -213,32 +208,50 @@ class OllamaLLM(BaseLLM):"""How long the model will stay loaded into memory."""base_url: Optional[str] = None- """Base url the model is hosted under."""+ """Base url the model is hosted under.++ If none, defaults to the Ollama client default.++ Supports `userinfo` auth in the format `http://username:password@localhost:11434`.+ Useful if your Ollama server is behind a proxy.++ !!! warning+ `userinfo` is not secure and should only be used for local testing or+ in secure environments. Avoid using it in production or over unsecured+ networks.++ !!! note+ If using `userinfo`, ensure that the Ollama server is configured to+ accept and validate these credentials.++ !!! note+ `userinfo` headers are passed to both sync and async clients.++ """client_kwargs: Optional[dict] = {}- """Additional kwargs to pass to the httpx clients.+ """Additional kwargs to pass to the httpx clients. Pass headers in here.These arguments are passed to both synchronous and async clients.Use ``sync_client_kwargs`` and ``async_client_kwargs`` to pass different argumentsto synchronous and asynchronous clients.-"""async_client_kwargs: Optional[dict] = {}- """Additional kwargs to merge with ``client_kwargs`` before passing to the HTTPX- AsyncClient.+ """Additional kwargs to merge with ``client_kwargs`` before passing to httpx client.- For a full list of the params, see the `HTTPX documentation <https://www.python-httpx.org/api/#asyncclient>`__.+ These are clients unique to the async client; for shared args use ``client_kwargs``.+ For a full list of the params, see the `httpx documentation <https://www.python-httpx.org/api/#asyncclient>`__."""sync_client_kwargs: Optional[dict] = {}- """Additional kwargs to merge with ``client_kwargs`` before- passing to the HTTPX Client.+ """Additional kwargs to merge with ``client_kwargs`` before passing to httpx client.- For a full list of the params, see the `HTTPX documentation <https://www.python-httpx.org/api/#client>`__.+ These are clients unique to the sync client; for shared args use ``client_kwargs``.+ For a full list of the params, see the `httpx documentation <https://www.python-httpx.org/api/#client>`__."""_client: Optional[Client] = PrivateAttr(default=None)@@ -310,6 +323,9 @@ class OllamaLLM(BaseLLM):"""Set clients to use for ollama."""client_kwargs = self.client_kwargs or {}+ cleaned_url, auth_headers = parse_url_with_auth(self.base_url)+ merge_auth_headers(client_kwargs, auth_headers)+sync_client_kwargs = client_kwargsif self.sync_client_kwargs:sync_client_kwargs = {**sync_client_kwargs, **self.sync_client_kwargs}@@ -318,8 +334,8 @@ class OllamaLLM(BaseLLM):if self.async_client_kwargs:async_client_kwargs = {**async_client_kwargs, **self.async_client_kwargs}- self._client = Client(host=self.base_url, **sync_client_kwargs)- self._async_client = AsyncClient(host=self.base_url, **async_client_kwargs)+ self._client = Client(host=cleaned_url, **sync_client_kwargs)+ self._async_client = AsyncClient(host=cleaned_url, **async_client_kwargs)if self.validate_model_on_init:validate_model(self._client, self.model)return selfdiff --git a/libs/partners/ollama/tests/unit_tests/test_auth.py b/libs/partners/ollama/tests/unit_tests/test_auth.pynew file mode 100644index 0000000000..1db36d46d8--- /dev/null+++ b/libs/partners/ollama/tests/unit_tests/test_auth.py@@ -0,0 +1,231 @@+"""Test URL authentication parsing functionality."""++import base64+from unittest.mock import MagicMock, patch++from langchain_ollama._utils import parse_url_with_auth+from langchain_ollama.chat_models import ChatOllama+from langchain_ollama.embeddings import OllamaEmbeddings+from langchain_ollama.llms import OllamaLLM++MODEL_NAME = "llama3.1"+++class TestParseUrlWithAuth:+ """Test the parse_url_with_auth utility function."""++ def test_parse_url_with_auth_none_input(self) -> None:+ """Test that None input returns None, None."""+ result = parse_url_with_auth(None)+ assert result == (None, None)++ def test_parse_url_with_auth_no_credentials(self) -> None:+ """Test URLs without authentication credentials."""+ url = "https://ollama.example.com:11434/path?query=param"+ result = parse_url_with_auth(url)+ assert result == (url, None)++ def test_parse_url_with_auth_with_credentials(self) -> None:+ """Test URLs with authentication credentials."""+ url = "https://user:[email protected]:11434"+ cleaned_url, headers = parse_url_with_auth(url)++ expected_url = "https://ollama.example.com:11434"+ expected_credentials = base64.b64encode(b"user:password").decode()+ expected_headers = {"Authorization": f"Basic {expected_credentials}"}++ assert cleaned_url == expected_url+ assert headers == expected_headers++ def test_parse_url_with_auth_with_path_and_query(self) -> None:+ """Test URLs with auth, path, and query parameters."""+ url = "https://user:[email protected]:11434/api/v1?timeout=30"+ cleaned_url, headers = parse_url_with_auth(url)++ expected_url = "https://ollama.example.com:11434/api/v1?timeout=30"+ expected_credentials = base64.b64encode(b"user:pass").decode()+ expected_headers = {"Authorization": f"Basic {expected_credentials}"}++ assert cleaned_url == expected_url+ assert headers == expected_headers++ def test_parse_url_with_auth_special_characters(self) -> None:+ """Test URLs with special characters in credentials."""+ url = "https://user%40domain:p%[email protected]:11434"+ cleaned_url, headers = parse_url_with_auth(url)++ expected_url = "https://ollama.example.com:11434"+ # Note: URL parsing handles percent-encoding automatically+ expected_credentials = base64.b64encode(b"user@domain:p@ssw0rd").decode()+ expected_headers = {"Authorization": f"Basic {expected_credentials}"}++ assert cleaned_url == expected_url+ assert headers == expected_headers++ def test_parse_url_with_auth_only_username(self) -> None:+ """Test URLs with only username (no password)."""+ url = "https://[email protected]:11434"+ cleaned_url, headers = parse_url_with_auth(url)++ expected_url = "https://ollama.example.com:11434"+ expected_credentials = base64.b64encode(b"user:").decode()+ expected_headers = {"Authorization": f"Basic {expected_credentials}"}++ assert cleaned_url == expected_url+ assert headers == expected_headers++ def test_parse_url_with_auth_empty_password(self) -> None:+ """Test URLs with empty password."""+ url = "https://user:@ollama.example.com:11434"+ cleaned_url, headers = parse_url_with_auth(url)++ expected_url = "https://ollama.example.com:11434"+ expected_credentials = base64.b64encode(b"user:").decode()+ expected_headers = {"Authorization": f"Basic {expected_credentials}"}++ assert cleaned_url == expected_url+ assert headers == expected_headers+++class TestChatOllamaUrlAuth:+ """Test URL authentication integration with ChatOllama."""++ @patch("langchain_ollama.chat_models.Client")+ @patch("langchain_ollama.chat_models.AsyncClient")+ def test_chat_ollama_url_auth_integration(+ self, mock_async_client: MagicMock, mock_client: MagicMock+ ) -> None:+ """Test that ChatOllama properly handles URL authentication."""+ url_with_auth = "https://user:[email protected]:11434"++ ChatOllama(+ model=MODEL_NAME,+ base_url=url_with_auth,+ )++ # Verify the clients were called with cleaned URL and auth headers+ expected_url = "https://ollama.example.com:11434"+ expected_credentials = base64.b64encode(b"user:password").decode()+ expected_headers = {"Authorization": f"Basic {expected_credentials}"}++ mock_client.assert_called_once_with(host=expected_url, headers=expected_headers)+ mock_async_client.assert_called_once_with(+ host=expected_url, headers=expected_headers+ )++ @patch("langchain_ollama.chat_models.Client")+ @patch("langchain_ollama.chat_models.AsyncClient")+ def test_chat_ollama_url_auth_with_existing_headers(+ self, mock_async_client: MagicMock, mock_client: MagicMock+ ) -> None:+ """Test that URL auth headers merge with existing headers."""+ url_with_auth = "https://user:[email protected]:11434"+ existing_headers = {"User-Agent": "test-agent", "X-Custom": "value"}++ ChatOllama(+ model=MODEL_NAME,+ base_url=url_with_auth,+ client_kwargs={"headers": existing_headers},+ )++ # Verify headers are merged+ expected_url = "https://ollama.example.com:11434"+ expected_credentials = base64.b64encode(b"user:password").decode()+ expected_headers = {+ **existing_headers,+ "Authorization": f"Basic {expected_credentials}",+ }++ mock_client.assert_called_once_with(host=expected_url, headers=expected_headers)+ mock_async_client.assert_called_once_with(+ host=expected_url, headers=expected_headers+ )+++class TestOllamaLLMUrlAuth:+ """Test URL authentication integration with OllamaLLM."""++ @patch("langchain_ollama.llms.Client")+ @patch("langchain_ollama.llms.AsyncClient")+ def test_ollama_llm_url_auth_integration(+ self, mock_async_client: MagicMock, mock_client: MagicMock+ ) -> None:+ """Test that OllamaLLM properly handles URL authentication."""+ url_with_auth = "https://user:[email protected]:11434"++ OllamaLLM(+ model=MODEL_NAME,+ base_url=url_with_auth,+ )++ expected_url = "https://ollama.example.com:11434"+ expected_credentials = base64.b64encode(b"user:password").decode()+ expected_headers = {"Authorization": f"Basic {expected_credentials}"}++ mock_client.assert_called_once_with(host=expected_url, headers=expected_headers)+ mock_async_client.assert_called_once_with(+ host=expected_url, headers=expected_headers+ )+++class TestOllamaEmbeddingsUrlAuth:+ """Test URL authentication integration with OllamaEmbeddings."""++ @patch("langchain_ollama.embeddings.Client")+ @patch("langchain_ollama.embeddings.AsyncClient")+ def test_ollama_embeddings_url_auth_integration(+ self, mock_async_client: MagicMock, mock_client: MagicMock+ ) -> None:+ """Test that OllamaEmbeddings properly handles URL authentication."""+ url_with_auth = "https://user:[email protected]:11434"++ OllamaEmbeddings(+ model=MODEL_NAME,+ base_url=url_with_auth,+ )++ expected_url = "https://ollama.example.com:11434"+ expected_credentials = base64.b64encode(b"user:password").decode()+ expected_headers = {"Authorization": f"Basic {expected_credentials}"}++ mock_client.assert_called_once_with(host=expected_url, headers=expected_headers)+ mock_async_client.assert_called_once_with(+ host=expected_url, headers=expected_headers+ )+++class TestUrlAuthEdgeCases:+ """Test edge cases and error conditions for URL authentication."""++ def test_parse_url_with_auth_malformed_url(self) -> None:+ """Test behavior with malformed URLs."""+ malformed_url = "not-a-valid-url"+ result = parse_url_with_auth(malformed_url)+ # Shouldn't return a URL as it wouldn't parse correctly or reach a server+ assert result == (None, None)++ def test_parse_url_with_auth_no_port(self) -> None:+ """Test URLs without explicit port numbers."""+ url = "https://user:[email protected]"+ cleaned_url, headers = parse_url_with_auth(url)++ expected_url = "https://ollama.example.com"+ expected_credentials = base64.b64encode(b"user:password").decode()+ expected_headers = {"Authorization": f"Basic {expected_credentials}"}++ assert cleaned_url == expected_url+ assert headers == expected_headers++ def test_parse_url_with_auth_complex_password(self) -> None:+ """Test with complex passwords containing special characters."""+ # Test password with colon, which is the delimiter+ url = "https://user:pass:[email protected]:11434"+ cleaned_url, headers = parse_url_with_auth(url)++ expected_url = "https://ollama.example.com:11434"+ # The parser should handle the first colon as the separator+ expected_credentials = base64.b64encode(b"user:pass:word").decode()+ expected_headers = {"Authorization": f"Basic {expected_credentials}"}++ assert cleaned_url == expected_url+ assert headers == expected_headersdiff --git a/libs/partners/ollama/uv.lock b/libs/partners/ollama/uv.lockindex 027f4797b4..148d9b2b58 100644--- a/libs/partners/ollama/uv.lock+++ b/libs/partners/ollama/uv.lock@@ -323,7 +323,7 @@ wheels = [[[package]]name = "langchain-core"-version = "0.3.76"+version = "0.3.77"source = { editable = "../../core" }dependencies = [{ name = "jsonpatch" },@@ -435,7 +435,7 @@ typing = [[[package]]name = "langchain-tests"-version = "0.3.21"+version = "0.3.22"source = { editable = "../../standard-tests" }dependencies = [{ name = "httpx" },