LLM from custom URL

[BrazilForever11]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

Please see in description

Description

I have been given access to custom LLM api. I can communicated with is using Postman. I would like to bring it to Langchain.

Here is how my URL looks

https://some_env.azurewebsites.net/api/company_api_endpoint?code=some_very_long_probably_key.

I tried it the following:

from langchain.chat_models import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
llm = ChatOpenAI(
        openai_api_base="https://some_env.azurewebsites.net/api/company_api_endpoint",  
        openai_api_key="some_very_long_probably_key",
        model_name="CustomGPT" 
    )
messages = [
    SystemMessage("Translate the following from English into Italian"),
    HumanMessage("hi!"),
]

llm.invoke(messages)

It returns NotFoundError: Error code: 404

I also tried:

llm = ChatOpenAI(
openai_api_base="https://some_env.azurewebsites.net/api/company_api_endpoint?code=some_very_long_probably_key",  
openai_api_key="no_key_here",
model_name="CustomGPT"
)

In this case I am getting back AuthenticationError: Error code: 401

Here is full error message:

---------------------------------------------------------------------------
AuthenticationError                       Traceback (most recent call last)
File c:\Users\some_user\OneDrive - some_company\Projects\Copilot initiatives\Copilot_initiatives\Langchain\some_companyGPT test.py:6
      1 messages = [
      2     SystemMessage("Translate the following from English into Italian"),
      3     HumanMessage("hi!"),
      4 ]
----> 6 llm.invoke(messages)

File c:\Users\some_user\myenv\Lib\site-packages\langchain_core\language_models\chat_models.py:286, in BaseChatModel.invoke(self, input, config, stop, **kwargs)
    275 def invoke(
    276     self,
    277     input: LanguageModelInput,
   (...)
    281     **kwargs: Any,
    282 ) -> BaseMessage:
    283     config = ensure_config(config)
    284     return cast(
    285         ChatGeneration,
--> 286         self.generate_prompt(
    287             [self._convert_input(input)],
    288             stop=stop,
    289             callbacks=config.get("callbacks"),
    290             tags=config.get("tags"),
    291             metadata=config.get("metadata"),
    292             run_name=config.get("run_name"),
    293             run_id=config.pop("run_id", None),
    294             **kwargs,
    295         ).generations[0][0],
    296     ).message

File c:\Users\some_user\myenv\Lib\site-packages\langchain_core\language_models\chat_models.py:786, in BaseChatModel.generate_prompt(self, prompts, stop, callbacks, **kwargs)
    778 def generate_prompt(
    779     self,
    780     prompts: list[PromptValue],
   (...)
    783     **kwargs: Any,
    784 ) -> LLMResult:
    785     prompt_messages = [p.to_messages() for p in prompts]
--> 786     return self.generate(prompt_messages, stop=stop, callbacks=callbacks, **kwargs)

File c:\Users\some_user\myenv\Lib\site-packages\langchain_core\language_models\chat_models.py:643, in BaseChatModel.generate(self, messages, stop, callbacks, tags, metadata, run_name, run_id, **kwargs)
    641         if run_managers:
    642             run_managers[i].on_llm_error(e, response=LLMResult(generations=[]))
--> 643         raise e
    644 flattened_outputs = [
    645     LLMResult(generations=[res.generations], llm_output=res.llm_output)  # type: ignore[list-item]
    646     for res in results
    647 ]
    648 llm_output = self._combine_llm_outputs([res.llm_output for res in results])

File c:\Users\some_user\myenv\Lib\site-packages\langchain_core\language_models\chat_models.py:633, in BaseChatModel.generate(self, messages, stop, callbacks, tags, metadata, run_name, run_id, **kwargs)
    630 for i, m in enumerate(messages):
    631     try:
    632         results.append(
--> 633             self._generate_with_cache(
    634                 m,
    635                 stop=stop,
    636                 run_manager=run_managers[i] if run_managers else None,
    637                 **kwargs,
    638             )
    639         )
    640     except BaseException as e:
    641         if run_managers:

File c:\Users\some_user\myenv\Lib\site-packages\langchain_core\language_models\chat_models.py:851, in BaseChatModel._generate_with_cache(self, messages, stop, run_manager, **kwargs)
    849 else:
    850     if inspect.signature(self._generate).parameters.get("run_manager"):
--> 851         result = self._generate(
    852             messages, stop=stop, run_manager=run_manager, **kwargs
    853         )
    854     else:
    855         result = self._generate(messages, stop=stop, **kwargs)

File c:\Users\some_user\myenv\Lib\site-packages\langchain_community\chat_models\openai.py:476, in ChatOpenAI._generate(self, messages, stop, run_manager, stream, **kwargs)
    470 message_dicts, params = self._create_message_dicts(messages, stop)
    471 params = {
    472     **params,
    473     **({"stream": stream} if stream is not None else {}),
    474     **kwargs,
    475 }
--> 476 response = self.completion_with_retry(
    477     messages=message_dicts, run_manager=run_manager, **params
    478 )
    479 return self._create_chat_result(response)

File c:\Users\some_user\myenv\Lib\site-packages\langchain_community\chat_models\openai.py:387, in ChatOpenAI.completion_with_retry(self, run_manager, **kwargs)
    385 """Use tenacity to retry the completion call."""
    386 if is_openai_v1():
--> 387     return self.client.create(**kwargs)
    389 retry_decorator = _create_retry_decorator(self, run_manager=run_manager)
    391 @retry_decorator
    392 def _completion_with_retry(**kwargs: Any) -> Any:

File c:\Users\some_user\myenv\Lib\site-packages\openai\_utils\_utils.py:279, in required_args.<locals>.inner.<locals>.wrapper(*args, **kwargs)
    277             msg = f"Missing required argument: {quote(missing[0])}"
    278     raise TypeError(msg)
--> 279 return func(*args, **kwargs)

File c:\Users\some_user\myenv\Lib\site-packages\openai\resources\chat\completions.py:859, in Completions.create(self, messages, model, audio, frequency_penalty, function_call, functions, logit_bias, logprobs, max_completion_tokens, max_tokens, metadata, modalities, n, parallel_tool_calls, prediction, presence_penalty, reasoning_effort, response_format, seed, service_tier, stop, store, stream, stream_options, temperature, tool_choice, tools, top_logprobs, top_p, user, extra_headers, extra_query, extra_body, timeout)
    817 @required_args(["messages", "model"], ["messages", "model", "stream"])
    818 def create(
    819     self,
   (...)
    856     timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
    857 ) -> ChatCompletion | Stream[ChatCompletionChunk]:
    858     validate_response_format(response_format)
--> 859     return self._post(
    860         "/chat/completions",
    861         body=maybe_transform(
    862             {
    863                 "messages": messages,
    864                 "model": model,
    865                 "audio": audio,
    866                 "frequency_penalty": frequency_penalty,
    867                 "function_call": function_call,
    868                 "functions": functions,
    869                 "logit_bias": logit_bias,
    870                 "logprobs": logprobs,
    871                 "max_completion_tokens": max_completion_tokens,
    872                 "max_tokens": max_tokens,
    873                 "metadata": metadata,
    874                 "modalities": modalities,
    875                 "n": n,
    876                 "parallel_tool_calls": parallel_tool_calls,
    877                 "prediction": prediction,
    878                 "presence_penalty": presence_penalty,
    879                 "reasoning_effort": reasoning_effort,
    880                 "response_format": response_format,
    881                 "seed": seed,
    882                 "service_tier": service_tier,
    883                 "stop": stop,
    884                 "store": store,
    885                 "stream": stream,
    886                 "stream_options": stream_options,
    887                 "temperature": temperature,
    888                 "tool_choice": tool_choice,
    889                 "tools": tools,
    890                 "top_logprobs": top_logprobs,
    891                 "top_p": top_p,
    892                 "user": user,
    893             },
    894             completion_create_params.CompletionCreateParams,
    895         ),
    896         options=make_request_options(
    897             extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
    898         ),
    899         cast_to=ChatCompletion,
    900         stream=stream or False,
    901         stream_cls=Stream[ChatCompletionChunk],
    902     )

File c:\Users\some_user\myenv\Lib\site-packages\openai\_base_client.py:1283, in SyncAPIClient.post(self, path, cast_to, body, options, files, stream, stream_cls)
   1269 def post(
   1270     self,
   1271     path: str,
   (...)
   1278     stream_cls: type[_StreamT] | None = None,
   1279 ) -> ResponseT | _StreamT:
   1280     opts = FinalRequestOptions.construct(
   1281         method="post", url=path, json_data=body, files=to_httpx_files(files), **options
   1282     )
-> 1283     return cast(ResponseT, self.request(cast_to, opts, stream=stream, stream_cls=stream_cls))

File c:\Users\some_user\myenv\Lib\site-packages\openai\_base_client.py:960, in SyncAPIClient.request(self, cast_to, options, remaining_retries, stream, stream_cls)
    957 else:
    958     retries_taken = 0
--> 960 return self._request(
    961     cast_to=cast_to,
    962     options=options,
    963     stream=stream,
    964     stream_cls=stream_cls,
    965     retries_taken=retries_taken,
    966 )

File c:\Users\some_user\myenv\Lib\site-packages\openai\_base_client.py:1064, in SyncAPIClient._request(self, cast_to, options, retries_taken, stream, stream_cls)
   1061         err.response.read()
   1063     log.debug("Re-raising status error")
-> 1064     raise self._make_status_error_from_response(err.response) from None
   1066 return self._process_response(
   1067     cast_to=cast_to,
   1068     options=options,
   (...)
   1072     retries_taken=retries_taken,
   1073 )

AuthenticationError: Error code: 401

What could be wrong here?

System Info

python 3.11