first commit

packages/@n8n/nodes-langchain/credentials/AnthropicApi.credentials.ts

@@ -0,0 +1,100 @@
+import type {
+	ICredentialDataDecryptedObject,
+	ICredentialTestRequest,
+	ICredentialType,
+	IHttpRequestOptions,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class AnthropicApi implements ICredentialType {
+	name = 'anthropicApi';
+
+	displayName = 'Anthropic';
+
+	documentationUrl = 'anthropic';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+		{
+			displayName: 'Base URL',
+			name: 'url',
+			type: 'string',
+			default: 'https://api.anthropic.com',
+			description: 'Override the default base URL for the API',
+		},
+		{
+			displayName: 'Add Custom Header',
+			name: 'header',
+			type: 'boolean',
+			default: false,
+		},
+		{
+			displayName: 'Header Name',
+			name: 'headerName',
+			type: 'string',
+			displayOptions: {
+				show: {
+					header: [true],
+				},
+			},
+			default: '',
+		},
+		{
+			displayName: 'Header Value',
+			name: 'headerValue',
+			type: 'string',
+			typeOptions: {
+				password: true,
+			},
+			displayOptions: {
+				show: {
+					header: [true],
+				},
+			},
+			default: '',
+		},
+	];
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{$credentials?.url}}',
+			url: '/v1/messages',
+			method: 'POST',
+			headers: {
+				'anthropic-version': '2023-06-01',
+			},
+			body: {
+				model: 'claude-3-haiku-20240307',
+				messages: [{ role: 'user', content: 'Hey' }],
+				max_tokens: 1,
+			},
+		},
+	};
+
+	async authenticate(
+		credentials: ICredentialDataDecryptedObject,
+		requestOptions: IHttpRequestOptions,
+	): Promise<IHttpRequestOptions> {
+		requestOptions.headers ??= {};
+
+		requestOptions.headers['x-api-key'] = credentials.apiKey;
+
+		if (
+			credentials.header &&
+			typeof credentials.headerName === 'string' &&
+			credentials.headerName &&
+			typeof credentials.headerValue === 'string'
+		) {
+			requestOptions.headers[credentials.headerName] = credentials.headerValue;
+		}
+
+		return requestOptions;
+	}
+}

packages/@n8n/nodes-langchain/credentials/AzureAiSearchApi.credentials.ts

@@ -0,0 +1,61 @@
+import type {
+	ICredentialDataDecryptedObject,
+	ICredentialTestRequest,
+	ICredentialType,
+	IHttpRequestOptions,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class AzureAiSearchApi implements ICredentialType {
+	name = 'azureAiSearchApi';
+
+	displayName = 'Azure AI Search API';
+
+	documentationUrl = 'azureaisearch';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'Search Endpoint',
+			name: 'endpoint',
+			type: 'string',
+			required: true,
+			default: '',
+			placeholder: 'https://your-search-service.search.windows.net',
+		},
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+	];
+
+	authenticate = async (
+		credentials: ICredentialDataDecryptedObject,
+		requestOptions: IHttpRequestOptions,
+	): Promise<IHttpRequestOptions> => {
+		return {
+			...requestOptions,
+			headers: {
+				...requestOptions.headers,
+				'api-key': credentials.apiKey,
+			},
+		};
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{$credentials.endpoint}}/indexes',
+			url: '',
+			method: 'GET',
+			headers: {
+				accept: 'application/json',
+			},
+			qs: {
+				'api-version': '2024-07-01',
+			},
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/AzureEntraCognitiveServicesOAuth2Api.credentials.ts

@@ -0,0 +1,114 @@
+import type { ICredentialType, INodeProperties } from 'n8n-workflow';
+
+const defaultScopes = ['openid', 'offline_access'];
+
+export class AzureEntraCognitiveServicesOAuth2Api implements ICredentialType {
+	name = 'azureEntraCognitiveServicesOAuth2Api';
+
+	// eslint-disable-next-line n8n-nodes-base/cred-class-field-display-name-missing-oauth2
+	displayName = 'Azure Entra ID (Azure Active Directory) API';
+
+	extends = ['oAuth2Api'];
+
+	documentationUrl = 'azureentracognitiveservicesoauth2api';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'Grant Type',
+			name: 'grantType',
+			type: 'hidden',
+			default: 'authorizationCode',
+		},
+		{
+			displayName: 'Resource Name',
+			name: 'resourceName',
+			type: 'string',
+			required: true,
+			default: '',
+		},
+		{
+			displayName: 'API Version',
+			name: 'apiVersion',
+			type: 'string',
+			required: true,
+			default: '2025-03-01-preview',
+		},
+		{
+			displayName: 'Endpoint',
+			name: 'endpoint',
+			type: 'string',
+			default: undefined,
+			placeholder: 'https://westeurope.api.cognitive.microsoft.com',
+		},
+		{
+			displayName: 'Tenant ID',
+			name: 'tenantId',
+			type: 'string',
+			default: 'common',
+			description:
+				'Enter your Azure Tenant ID (Directory ID) or keep "common" for multi-tenant apps. Using a specific Tenant ID is generally recommended and required for certain authentication flows.',
+			placeholder: 'e.g., xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx or common',
+		},
+		{
+			displayName: 'Authorization URL',
+			name: 'authUrl',
+			type: 'hidden',
+			default: '=https://login.microsoftonline.com/{{$self["tenantId"]}}/oauth2/authorize',
+		},
+		{
+			displayName: 'Access Token URL',
+			name: 'accessTokenUrl',
+			type: 'hidden',
+			default: '=https://login.microsoftonline.com/{{$self["tenantId"]}}/oauth2/token',
+		},
+		{
+			displayName: 'Additional Body Properties',
+			name: 'additionalBodyProperties',
+			type: 'hidden',
+			default:
+				'{"grant_type": "client_credentials", "resource": "https://cognitiveservices.azure.com/"}',
+		},
+		{
+			displayName: 'Authentication',
+			name: 'authentication',
+			type: 'hidden',
+			default: 'body',
+		},
+		{
+			displayName: 'Custom Scopes',
+			name: 'customScopes',
+			type: 'boolean',
+			default: false,
+			description:
+				'Define custom scopes. You might need this if the default scopes are not sufficient or if you want to minimize permissions. Ensure you include "openid" and "offline_access".',
+		},
+		{
+			displayName: 'Auth URI Query Parameters',
+			name: 'authQueryParameters',
+			type: 'hidden',
+			default: '',
+			description:
+				'For some services additional query parameters have to be set which can be defined here',
+			placeholder: '',
+		},
+		{
+			displayName: 'Enabled Scopes',
+			name: 'enabledScopes',
+			type: 'string',
+			displayOptions: {
+				show: {
+					customScopes: [true],
+				},
+			},
+			default: defaultScopes.join(' '),
+			placeholder: 'openid offline_access',
+			description: 'Space-separated list of scopes to request.',
+		},
+		{
+			displayName: 'Scope',
+			name: 'scope',
+			type: 'hidden',
+			default: '={{ $self.customScopes ? $self.enabledScopes : "' + defaultScopes.join(' ') + '"}}',
+		},
+	];
+}

packages/@n8n/nodes-langchain/credentials/AzureOpenAiApi.credentials.ts

@@ -0,0 +1,50 @@
+import type { IAuthenticateGeneric, ICredentialType, INodeProperties } from 'n8n-workflow';
+
+export class AzureOpenAiApi implements ICredentialType {
+	name = 'azureOpenAiApi';
+
+	displayName = 'Azure Open AI';
+
+	documentationUrl = 'azureopenai';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+		{
+			displayName: 'Resource Name',
+			name: 'resourceName',
+			type: 'string',
+			required: true,
+			default: '',
+		},
+		{
+			displayName: 'API Version',
+			name: 'apiVersion',
+			type: 'string',
+			required: true,
+			default: '2025-03-01-preview',
+		},
+		{
+			displayName: 'Endpoint',
+			name: 'endpoint',
+			type: 'string',
+			default: undefined,
+			placeholder: 'https://westeurope.api.cognitive.microsoft.com',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				'api-key': '={{$credentials.apiKey}}',
+			},
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/ChromaCloudApi.credentials.ts

@@ -0,0 +1,64 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class ChromaCloudApi implements ICredentialType {
+	name = 'chromaCloudApi';
+
+	displayName = 'ChromaDB Cloud';
+
+	documentationUrl = 'chroma';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			default: '',
+			required: true,
+			description: 'Your Chroma Cloud API key',
+		},
+		{
+			displayName: 'Tenant ID',
+			name: 'tenant',
+			type: 'string',
+			default: '',
+			description: 'Optional: Tenant ID (auto-resolved if API key is scoped to single DB)',
+		},
+		{
+			displayName: 'Database Name',
+			name: 'database',
+			type: 'string',
+			default: '',
+			description: 'Optional: Database name (auto-resolved if API key is scoped to single DB)',
+		},
+		{
+			displayName: 'Base URL',
+			name: 'baseUrl',
+			type: 'string',
+			default: 'https://api.trychroma.com',
+			required: true,
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				'x-chroma-token': '={{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{$credentials.baseUrl}}',
+			url: '/api/v2',
+			method: 'GET',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/ChromaSelfHostedApi.credentials.ts

@@ -0,0 +1,90 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class ChromaSelfHostedApi implements ICredentialType {
+	name = 'chromaSelfHostedApi';
+
+	displayName = 'ChromaDB Self-Hosted';
+
+	documentationUrl = 'chroma';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'Base URL',
+			name: 'baseUrl',
+			type: 'string',
+			default: 'http://localhost:8000',
+			placeholder: 'http://localhost:8000',
+			description:
+				'The URL of your ChromaDB instance. Note that path prefixes are not supported, so the URL must point directly to the instance root.',
+		},
+		{
+			displayName: 'Authentication',
+			name: 'authentication',
+			type: 'options',
+			options: [
+				{
+					name: 'None',
+					value: 'none',
+				},
+				{
+					name: 'API Key',
+					value: 'apiKey',
+				},
+				{
+					name: 'Token',
+					value: 'token',
+				},
+			],
+			default: 'none',
+		},
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			default: '',
+			displayOptions: {
+				show: {
+					authentication: ['apiKey'],
+				},
+			},
+		},
+		{
+			displayName: 'Token',
+			name: 'token',
+			type: 'string',
+			typeOptions: { password: true },
+			default: '',
+			displayOptions: {
+				show: {
+					authentication: ['token'],
+				},
+			},
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization:
+					'={{$credentials.authentication === "apiKey" && $credentials.apiKey ? "Bearer " + $credentials.apiKey : ""}}',
+				'X-Chroma-Token':
+					'={{$credentials.authentication === "token" && $credentials.token ? $credentials.token : ""}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{$credentials.baseUrl}}',
+			url: '/api/v2/heartbeat',
+			method: 'GET',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/CohereApi.credentials.ts

@@ -0,0 +1,47 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class CohereApi implements ICredentialType {
+	name = 'cohereApi';
+
+	displayName = 'CohereApi';
+
+	documentationUrl = 'cohere';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+		{
+			displayName: 'Base URL',
+			name: 'url',
+			type: 'hidden',
+			default: 'https://api.cohere.ai',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization: '=Bearer {{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{ $credentials.url }}',
+			url: '/v1/models?page_size=1',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/DeepSeekApi.credentials.ts

@@ -0,0 +1,47 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class DeepSeekApi implements ICredentialType {
+	name = 'deepSeekApi';
+
+	displayName = 'DeepSeek';
+
+	documentationUrl = 'deepseek';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+		{
+			displayName: 'Base URL',
+			name: 'url',
+			type: 'hidden',
+			default: 'https://api.deepseek.com',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization: '=Bearer {{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{ $credentials.url }}',
+			url: '/models',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/GooglePalmApi.credentials.ts

@@ -0,0 +1,47 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class GooglePalmApi implements ICredentialType {
+	name = 'googlePalmApi';
+
+	displayName = 'Google Gemini(PaLM) Api';
+
+	documentationUrl = 'google';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'Host',
+			name: 'host',
+			required: true,
+			type: 'string',
+			default: 'https://generativelanguage.googleapis.com',
+		},
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			qs: {
+				key: '={{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{$credentials.host}}/v1beta/models',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/GroqApi.credentials.ts

@@ -0,0 +1,41 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class GroqApi implements ICredentialType {
+	name = 'groqApi';
+
+	displayName = 'Groq';
+
+	documentationUrl = 'groq';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization: '=Bearer {{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: 'https://api.groq.com/openai/v1',
+			url: '/models',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/HuggingFaceApi.credentials.ts

@@ -0,0 +1,41 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class HuggingFaceApi implements ICredentialType {
+	name = 'huggingFaceApi';
+
+	displayName = 'HuggingFaceApi';
+
+	documentationUrl = 'huggingface';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization: '=Bearer {{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: 'https://huggingface.co',
+			url: '/api/whoami-v2',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/LemonadeApi.credentials.ts

@@ -0,0 +1,62 @@
+import type {
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+	IHttpRequestOptions,
+	ICredentialDataDecryptedObject,
+} from 'n8n-workflow';
+
+export type LemonadeApiCredentialsType = {
+	baseUrl: string;
+	apiKey?: string;
+};
+
+export class LemonadeApi implements ICredentialType {
+	name = 'lemonadeApi';
+
+	displayName = 'Lemonade';
+
+	documentationUrl = 'lemonade';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'Base URL',
+			name: 'baseUrl',
+			required: true,
+			type: 'string',
+			default: 'http://localhost:8000/api/v1',
+		},
+		{
+			displayName: 'API Key',
+			hint: 'Optional API key for Lemonade server authentication. Not required for default Lemonade installation',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			default: '',
+			required: false,
+		},
+	];
+
+	async authenticate(
+		credentials: ICredentialDataDecryptedObject,
+		requestOptions: IHttpRequestOptions,
+	): Promise<IHttpRequestOptions> {
+		// Only add Authorization header if API key is provided and not empty
+		const apiKey = credentials.apiKey as string | undefined;
+		if (apiKey && apiKey.trim() !== '') {
+			requestOptions.headers = {
+				...requestOptions.headers,
+				Authorization: `Bearer ${apiKey}`,
+			};
+		}
+		return requestOptions;
+	}
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{ $credentials.baseUrl }}',
+			url: '/models',
+			method: 'GET',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/McpOAuth2Api.credentials.ts

@@ -0,0 +1,20 @@
+import type { ICredentialType, INodeProperties } from 'n8n-workflow';
+
+export class McpOAuth2Api implements ICredentialType {
+	name = 'mcpOAuth2Api';
+
+	extends = ['oAuth2Api'];
+
+	displayName = 'MCP OAuth2 API';
+
+	documentationUrl = 'mcp';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'Use Dynamic Client Registration',
+			name: 'useDynamicClientRegistration',
+			type: 'boolean',
+			default: true,
+		},
+	];
+}

packages/@n8n/nodes-langchain/credentials/MicrosoftAgent365Api.credentials.ts

@@ -0,0 +1,34 @@
+import type { ICredentialType, INodeProperties } from 'n8n-workflow';
+
+export class MicrosoftAgent365Api implements ICredentialType {
+	name = 'microsoftAgent365Api';
+
+	displayName = 'Microsoft 365 Agent API';
+
+	documentationUrl = 'microsoftagent365';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'Tenant ID',
+			name: 'tenantId',
+			type: 'string',
+			required: true,
+			default: '',
+		},
+		{
+			displayName: 'Client ID',
+			name: 'clientId',
+			type: 'string',
+			required: true,
+			default: '',
+		},
+		{
+			displayName: 'Client Secret',
+			name: 'clientSecret',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+	];
+}

packages/@n8n/nodes-langchain/credentials/MilvusApi.credentials.ts

@@ -0,0 +1,54 @@
+import type {
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+	IAuthenticateGeneric,
+} from 'n8n-workflow';
+
+export class MilvusApi implements ICredentialType {
+	name = 'milvusApi';
+
+	displayName = 'Milvus';
+
+	documentationUrl = 'milvus';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'Base URL',
+			name: 'baseUrl',
+			required: true,
+			type: 'string',
+			default: 'http://localhost:19530',
+		},
+		{
+			displayName: 'Username',
+			name: 'username',
+			type: 'string',
+			default: '',
+		},
+		{
+			displayName: 'Password',
+			name: 'password',
+			type: 'string',
+			typeOptions: { password: true },
+			default: '',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization: '=Bearer {{$credentials.username}}:{{$credentials.password}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{ $credentials.baseUrl }}',
+			url: '/v1/vector/collections',
+			method: 'GET',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/MistralCloudApi.credentials.ts

@@ -0,0 +1,42 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class MistralCloudApi implements ICredentialType {
+	name = 'mistralCloudApi';
+
+	displayName = 'Mistral Cloud API';
+
+	documentationUrl = 'mistral';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization: '=Bearer {{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: 'https://api.mistral.ai/v1',
+			url: '/models',
+			method: 'GET',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/MotorheadApi.credentials.ts

@@ -0,0 +1,54 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class MotorheadApi implements ICredentialType {
+	name = 'motorheadApi';
+
+	displayName = 'MotorheadApi';
+
+	documentationUrl = 'motorhead';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'Host',
+			name: 'host',
+			required: true,
+			type: 'string',
+			default: 'https://api.getmetal.io/v1',
+		},
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+		{
+			displayName: 'Client ID',
+			name: 'clientId',
+			type: 'string',
+			default: '',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				'x-metal-client-id': '={{$credentials.clientId}}',
+				'x-metal-api-key': '={{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{$credentials.host}}/keys/current',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/OllamaApi.credentials.ts

@@ -0,0 +1,50 @@
+import type {
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+	IAuthenticateGeneric,
+} from 'n8n-workflow';
+
+export class OllamaApi implements ICredentialType {
+	name = 'ollamaApi';
+
+	displayName = 'Ollama';
+
+	documentationUrl = 'ollama';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'Base URL',
+			name: 'baseUrl',
+			required: true,
+			type: 'string',
+			default: 'http://localhost:11434',
+		},
+		{
+			displayName: 'API Key',
+			hint: 'When using Ollama behind a proxy with authentication (such as Open WebUI), provide the Bearer token/API key here. This is not required for the default Ollama installation',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			default: '',
+			required: false,
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization: '=Bearer {{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{ $credentials.baseUrl }}',
+			url: '/api/tags',
+			method: 'GET',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/OpenRouterApi.credentials.ts

@@ -0,0 +1,47 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class OpenRouterApi implements ICredentialType {
+	name = 'openRouterApi';
+
+	displayName = 'OpenRouter';
+
+	documentationUrl = 'openrouter';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+		{
+			displayName: 'Base URL',
+			name: 'url',
+			type: 'hidden',
+			default: 'https://openrouter.ai/api/v1',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization: '=Bearer {{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{ $credentials.url }}',
+			url: '/key',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/PineconeApi.credentials.ts

@@ -0,0 +1,43 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class PineconeApi implements ICredentialType {
+	name = 'pineconeApi';
+
+	displayName = 'PineconeApi';
+
+	documentationUrl = 'pinecone';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				'Api-Key': '={{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: 'https://api.pinecone.io/indexes',
+			headers: {
+				accept: 'application/json; charset=utf-8',
+			},
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/QdrantApi.credentials.ts

@@ -0,0 +1,48 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class QdrantApi implements ICredentialType {
+	name = 'qdrantApi';
+
+	displayName = 'QdrantApi';
+
+	documentationUrl = 'https://docs.n8n.io/integrations/builtin/credentials/qdrant/';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: false,
+			default: '',
+		},
+		{
+			displayName: 'Qdrant URL',
+			name: 'qdrantUrl',
+			type: 'string',
+			required: true,
+			default: '',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				'api-key': '={{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{$credentials.qdrantUrl}}',
+			url: '/collections',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/SearXngApi.credentials.ts

@@ -0,0 +1,19 @@
+import type { ICredentialType, INodeProperties } from 'n8n-workflow';
+
+export class SearXngApi implements ICredentialType {
+	name = 'searXngApi';
+
+	displayName = 'SearXNG';
+
+	documentationUrl = 'searxng';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API URL',
+			name: 'apiUrl',
+			type: 'string',
+			default: '',
+			required: true,
+		},
+	];
+}

packages/@n8n/nodes-langchain/credentials/SerpApi.credentials.ts

@@ -0,0 +1,41 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class SerpApi implements ICredentialType {
+	name = 'serpApi';
+
+	displayName = 'SerpAPI';
+
+	documentationUrl = 'serp';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			qs: {
+				api_key: '={{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: 'https://serpapi.com',
+			url: '/account.json ',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/VercelAiGatewayApi.credentials.ts

@@ -0,0 +1,63 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class VercelAiGatewayApi implements ICredentialType {
+	name = 'vercelAiGatewayApi';
+
+	displayName = 'Vercel AI Gateway';
+
+	documentationUrl = 'vercel';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key or OIDC Token',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+			description: 'Your credentials for the Vercel AI Gateway',
+		},
+		{
+			displayName: 'Base URL',
+			name: 'url',
+			type: 'string',
+			required: true,
+			default: 'https://ai-gateway.vercel.sh/v1',
+			description: 'The base URL for your Vercel AI Gateway instance',
+			placeholder: 'https://ai-gateway.vercel.sh/v1',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization: '=Bearer {{$credentials.apiKey}}',
+				'http-referer': 'https://n8n.io/',
+				'x-title': 'n8n',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{ $credentials.url }}',
+			url: '/chat/completions',
+			method: 'POST',
+			headers: {
+				'http-referer': 'https://n8n.io/',
+				'x-title': 'n8n',
+			},
+			body: {
+				model: 'openai/gpt-4.1-nano',
+				messages: [{ role: 'user', content: 'test' }],
+				max_tokens: 1,
+			},
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/WeaviateApi.credentials.ts

@@ -0,0 +1,143 @@
+import type { ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+
+export class WeaviateApi implements ICredentialType {
+	name = 'weaviateApi';
+
+	displayName = 'Weaviate Credentials';
+
+	documentationUrl = 'https://docs.n8n.io/integrations/builtin/credentials/weaviate/';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'Connection Type',
+			name: 'connection_type',
+			type: 'options',
+			options: [
+				{
+					name: 'Weaviate Cloud',
+					value: 'weaviate_cloud',
+				},
+				{
+					name: 'Custom Connection',
+					value: 'custom_connection',
+				},
+			],
+			default: 'weaviate_cloud',
+			description:
+				'Choose whether to connect to a Weaviate Cloud instance or a custom Weaviate instance.',
+		},
+		{
+			displayName: 'Weaviate Cloud Endpoint',
+			name: 'weaviate_cloud_endpoint',
+			description: 'The Endpoint of a Weaviate Cloud instance.',
+			placeholder: 'https://your-cluster.weaviate.cloud',
+			type: 'string',
+			required: true,
+			default: '',
+			displayOptions: {
+				show: {
+					connection_type: ['weaviate_cloud'],
+				},
+			},
+		},
+		{
+			displayName: 'Weaviate Api Key',
+			name: 'weaviate_api_key',
+			description: 'The API key for the Weaviate instance.',
+			type: 'string',
+			typeOptions: { password: true },
+			default: '',
+		},
+		{
+			displayName: 'Custom Connection HTTP Host',
+			name: 'custom_connection_http_host',
+			description: 'The host of your Weaviate instance.',
+			type: 'string',
+			required: true,
+			default: 'weaviate',
+			displayOptions: {
+				show: {
+					connection_type: ['custom_connection'],
+				},
+			},
+		},
+		{
+			displayName: 'Custom Connection HTTP Port',
+			name: 'custom_connection_http_port',
+			description: 'The port of your Weaviate instance.',
+			type: 'number',
+			required: true,
+			default: 8080,
+			displayOptions: {
+				show: {
+					connection_type: ['custom_connection'],
+				},
+			},
+		},
+		{
+			displayName: 'Custom Connection HTTP Secure',
+			name: 'custom_connection_http_secure',
+			description: 'Whether to use a secure connection for HTTP.',
+			type: 'boolean',
+			required: true,
+			default: false,
+			displayOptions: {
+				show: {
+					connection_type: ['custom_connection'],
+				},
+			},
+		},
+		{
+			displayName: 'Custom Connection gRPC Host',
+			name: 'custom_connection_grpc_host',
+			description: 'The gRPC host of your Weaviate instance.',
+			type: 'string',
+			required: true,
+			default: 'weaviate',
+			displayOptions: {
+				show: {
+					connection_type: ['custom_connection'],
+				},
+			},
+		},
+		{
+			displayName: 'Custom Connection gRPC Port',
+			name: 'custom_connection_grpc_port',
+			description: 'The gRPC port of your Weaviate instance.',
+			type: 'number',
+			required: true,
+			default: 50051,
+			displayOptions: {
+				show: {
+					connection_type: ['custom_connection'],
+				},
+			},
+		},
+		{
+			displayName: 'Custom Connection gRPC Secure',
+			name: 'custom_connection_grpc_secure',
+			description: 'Whether to use a secure connection for gRPC.',
+			type: 'boolean',
+			required: true,
+			default: false,
+			displayOptions: {
+				show: {
+					connection_type: ['custom_connection'],
+				},
+			},
+		},
+	];
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL:
+				'={{$credentials.weaviate_cloud_endpoint?$credentials.weaviate_cloud_endpoint.startsWith("http://") || $credentials.weaviate_cloud_endpoint.startsWith("https://")?$credentials.weaviate_cloud_endpoint:"https://" + $credentials.weaviate_cloud_endpoint:($credentials.custom_connection_http_secure ? "https" : "http") + "://" + $credentials.custom_connection_http_host + ":" + $credentials.custom_connection_http_port }}',
+			url: '/v1/nodes',
+			disableFollowRedirect: false,
+			headers: {
+				Authorization:
+					'={{$if($credentials.weaviate_api_key, "Bearer " + $credentials.weaviate_api_key, undefined)}}',
+			},
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/WolframAlphaApi.credentials.ts

@@ -0,0 +1,45 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class WolframAlphaApi implements ICredentialType {
+	name = 'wolframAlphaApi';
+
+	displayName = 'WolframAlphaApi';
+
+	documentationUrl = 'wolframalpha';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'App ID',
+			name: 'appId',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			qs: {
+				api_key: '={{$credentials.appId}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: 'https://api.wolframalpha.com/v1',
+			url: '=/simple',
+			qs: {
+				i: 'How much is 1 1',
+				appid: '={{$credentials.appId}}',
+			},
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/XAiApi.credentials.ts

@@ -0,0 +1,47 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class XAiApi implements ICredentialType {
+	name = 'xAiApi';
+
+	displayName = 'xAi';
+
+	documentationUrl = 'xai';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+		{
+			displayName: 'Base URL',
+			name: 'url',
+			type: 'hidden',
+			default: 'https://api.x.ai/v1',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization: '=Bearer {{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{ $credentials.url }}',
+			url: '/models',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/XataApi.credentials.ts

@@ -0,0 +1,55 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class XataApi implements ICredentialType {
+	name = 'xataApi';
+
+	displayName = 'Xata Api';
+
+	documentationUrl = 'xata';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'Database Endpoint',
+			name: 'databaseEndpoint',
+			required: true,
+			type: 'string',
+			default: '',
+			placeholder: 'https://{workspace}.{region}.xata.sh/db/{database}',
+		},
+		{
+			displayName: 'Branch',
+			name: 'branch',
+			required: true,
+			type: 'string',
+			default: 'main',
+		},
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: true,
+			default: '',
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization: '=Bearer {{$credentials.apiKey}}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{$credentials.databaseEndpoint}}:{{$credentials.branch}}',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/ZepApi.credentials.ts

@@ -0,0 +1,67 @@
+import type {
+	IAuthenticateGeneric,
+	ICredentialTestRequest,
+	ICredentialType,
+	INodeProperties,
+} from 'n8n-workflow';
+
+export class ZepApi implements ICredentialType {
+	name = 'zepApi';
+
+	displayName = 'Zep Api';
+
+	documentationUrl = 'zep';
+
+	properties: INodeProperties[] = [
+		{
+			displayName: 'This Zep integration is deprecated and will be removed in a future version.',
+			name: 'deprecationNotice',
+			type: 'notice',
+			default: '',
+		},
+		{
+			displayName: 'API Key',
+			name: 'apiKey',
+			type: 'string',
+			typeOptions: { password: true },
+			required: false,
+			default: '',
+		},
+		{
+			displayName: 'Cloud',
+			description: 'Whether you are adding credentials for Zep Cloud instead of Zep Open Source',
+			name: 'cloud',
+			type: 'boolean',
+			default: false,
+		},
+		{
+			displayName: 'API URL',
+			name: 'apiUrl',
+			required: false,
+			type: 'string',
+			default: 'http://localhost:8000',
+			displayOptions: {
+				show: {
+					cloud: [false],
+				},
+			},
+		},
+	];
+
+	authenticate: IAuthenticateGeneric = {
+		type: 'generic',
+		properties: {
+			headers: {
+				Authorization:
+					'={{$credentials.apiKey && !$credentials.cloud ? "Bearer " + $credentials.apiKey : "Api-Key " + $credentials.apiKey }}',
+			},
+		},
+	};
+
+	test: ICredentialTestRequest = {
+		request: {
+			baseURL: '={{!$credentials.cloud ? $credentials.apiUrl : "https://api.getzep.com"}}',
+			url: '={{!$credentials.cloud ? "/api/v1/collection" : "/api/v2/collections"}}',
+		},
+	};
+}

packages/@n8n/nodes-langchain/credentials/test/AnthropicApi.credentials.test.ts

@@ -0,0 +1,158 @@
+import type { ICredentialDataDecryptedObject, IHttpRequestOptions } from 'n8n-workflow';
+
+import { AnthropicApi } from '../AnthropicApi.credentials';
+
+describe('AnthropicApi Credential', () => {
+	const anthropicApi = new AnthropicApi();
+
+	it('should have correct properties', () => {
+		expect(anthropicApi.name).toBe('anthropicApi');
+		expect(anthropicApi.displayName).toBe('Anthropic');
+		expect(anthropicApi.documentationUrl).toBe('anthropic');
+		expect(anthropicApi.properties).toHaveLength(5);
+		expect(anthropicApi.test.request.baseURL).toBe('={{$credentials?.url}}');
+		expect(anthropicApi.test.request.url).toBe('/v1/messages');
+	});
+
+	describe('authenticate', () => {
+		it('should add x-api-key header with API key only', async () => {
+			const credentials: ICredentialDataDecryptedObject = {
+				apiKey: 'sk-ant-test123456789',
+			};
+
+			const requestOptions: IHttpRequestOptions = {
+				headers: {},
+				url: '/v1/messages',
+				baseURL: 'https://api.anthropic.com',
+			};
+
+			const result = await anthropicApi.authenticate(credentials, requestOptions);
+
+			expect(result.headers).toEqual({
+				'x-api-key': 'sk-ant-test123456789',
+			});
+		});
+
+		it('should add custom header when header toggle is enabled', async () => {
+			const credentials: ICredentialDataDecryptedObject = {
+				apiKey: 'sk-ant-test123456789',
+				header: true,
+				headerName: 'X-Custom-Header',
+				headerValue: 'custom-value-123',
+			};
+
+			const requestOptions: IHttpRequestOptions = {
+				headers: {},
+				url: '/v1/messages',
+				baseURL: 'https://api.anthropic.com',
+			};
+
+			const result = await anthropicApi.authenticate(credentials, requestOptions);
+
+			expect(result.headers).toEqual({
+				'x-api-key': 'sk-ant-test123456789',
+				'X-Custom-Header': 'custom-value-123',
+			});
+		});
+
+		it('should not add custom header when header toggle is disabled', async () => {
+			const credentials: ICredentialDataDecryptedObject = {
+				apiKey: 'sk-ant-test123456789',
+				header: false,
+				headerName: 'X-Custom-Header',
+				headerValue: 'custom-value-123',
+			};
+
+			const requestOptions: IHttpRequestOptions = {
+				headers: {},
+				url: '/v1/messages',
+				baseURL: 'https://api.anthropic.com',
+			};
+
+			const result = await anthropicApi.authenticate(credentials, requestOptions);
+
+			expect(result.headers).toEqual({
+				'x-api-key': 'sk-ant-test123456789',
+			});
+			expect(result.headers?.['X-Custom-Header']).toBeUndefined();
+		});
+
+		it('should preserve existing headers', async () => {
+			const credentials: ICredentialDataDecryptedObject = {
+				apiKey: 'sk-ant-test123456789',
+				header: true,
+				headerName: 'X-Custom-Header',
+				headerValue: 'custom-value-123',
+			};
+
+			const requestOptions: IHttpRequestOptions = {
+				url: '/v1/messages',
+				baseURL: 'https://api.anthropic.com',
+			};
+
+			const result = await anthropicApi.authenticate(credentials, requestOptions);
+
+			const raw =
+				typeof (result.headers as any)?.get === 'function'
+					? Object.fromEntries((result.headers as unknown as Headers).entries())
+					: (result.headers as Record<string, string | undefined>);
+
+			const headers = Object.fromEntries(Object.entries(raw).map(([k, v]) => [k.toLowerCase(), v]));
+
+			expect(headers).toEqual(
+				expect.objectContaining({
+					'x-api-key': 'sk-ant-test123456789',
+					'x-custom-header': 'custom-value-123',
+				}),
+			);
+		});
+
+		it('should preserve existing headers when adding auth headers', async () => {
+			const credentials: ICredentialDataDecryptedObject = {
+				apiKey: 'sk-ant-test123456789',
+			};
+
+			const requestOptions: IHttpRequestOptions = {
+				headers: {
+					'anthropic-version': '2023-06-01',
+				},
+				url: '/v1/messages',
+				baseURL: 'https://api.anthropic.com',
+			};
+
+			const result = await anthropicApi.authenticate(credentials, requestOptions);
+
+			expect(result.headers).toEqual({
+				'anthropic-version': '2023-06-01',
+				'x-api-key': 'sk-ant-test123456789',
+			});
+		});
+
+		it('should preserve existing headers even with custom header option enabled', async () => {
+			const credentials: ICredentialDataDecryptedObject = {
+				apiKey: 'sk-ant-test123456789',
+				header: true,
+				headerName: 'X-Additional-Header',
+				headerValue: 'additional-value',
+			};
+
+			const requestOptions: IHttpRequestOptions = {
+				headers: {
+					'anthropic-version': '2023-06-01',
+					'X-Existing-Header': 'existing-value',
+				},
+				url: '/v1/messages',
+				baseURL: 'https://api.anthropic.com',
+			};
+
+			const result = await anthropicApi.authenticate(credentials, requestOptions);
+
+			expect(result.headers).toEqual({
+				'anthropic-version': '2023-06-01',
+				'X-Existing-Header': 'existing-value',
+				'x-api-key': 'sk-ant-test123456789',
+				'X-Additional-Header': 'additional-value',
+			});
+		});
+	});
+});

packages/@n8n/nodes-langchain/credentials/test/ChromaCloudApi.credentials.test.ts

@@ -0,0 +1,49 @@
+import { ChromaCloudApi } from '../ChromaCloudApi.credentials';
+
+describe('ChromaCloudApi Credential', () => {
+	const chromaCloudApi = new ChromaCloudApi();
+
+	it('should have correct properties', () => {
+		expect(chromaCloudApi.name).toBe('chromaCloudApi');
+		expect(chromaCloudApi.displayName).toBe('ChromaDB Cloud');
+		expect(chromaCloudApi.documentationUrl).toBe('chroma');
+		expect(chromaCloudApi.properties).toHaveLength(4);
+
+		const baseUrlProp = chromaCloudApi.properties.find((p) => p.name === 'baseUrl');
+		expect(baseUrlProp).toBeDefined();
+		expect(baseUrlProp?.default).toBe('https://api.trychroma.com');
+		expect(baseUrlProp?.required).toBe(true);
+
+		expect(chromaCloudApi.test.request.baseURL).toBe('={{$credentials.baseUrl}}');
+		expect(chromaCloudApi.test.request.url).toBe('/api/v2');
+	});
+
+	it('should have correct authentication', () => {
+		expect(chromaCloudApi.authenticate).toBeDefined();
+		expect(chromaCloudApi.authenticate.type).toBe('generic');
+		expect((chromaCloudApi.authenticate.properties as any).headers).toBeDefined();
+		expect((chromaCloudApi.authenticate.properties as any).headers['x-chroma-token']).toBe(
+			'={{$credentials.apiKey}}',
+		);
+	});
+	const chromaCloudApi2 = new ChromaCloudApi();
+	it('should use changed baseUrl in test request when property is modified', () => {
+		const customBaseUrl = 'https://custom.chroma.example.com';
+
+		const baseUrlProp = chromaCloudApi2.properties.find((p) => p.name === 'baseUrl');
+		expect(baseUrlProp).toBeDefined();
+		baseUrlProp!.default = customBaseUrl;
+
+		expect(baseUrlProp!.default).toBe(customBaseUrl);
+
+		const baseURLExpression = chromaCloudApi2.test.request.baseURL;
+		expect(baseURLExpression).toBe('={{$credentials.baseUrl}}');
+
+		const credentials = { baseUrl: baseUrlProp!.default };
+		const resolvedBaseURL = baseURLExpression?.replace(
+			/=\{\{\$credentials\.(\w+)\}\}/,
+			(_, key) => credentials[key as keyof typeof credentials],
+		);
+		expect(resolvedBaseURL).toBe(customBaseUrl);
+	});
+});