Instructor: As you saw throughout this section,
there's quite a lot you can do with open models
through LM Studio,
and there's quite a lot you can configure,
but there's even more you can do
with locally running models when using LM Studio,
because you can not just use them through LM Studio,
but you can also use them programmatically.
So you could build your own applications
that rely on your own locally running models,
so that you don't have to pay for the usage
of the API of some proprietary model out there.
Now, just to make sure we're all on the same page,
one of the most common ways of using large language models,
no matter if we're talking about open,
locally running models,
as we covered it here in this course,
or if we're talking about ChatGPT
or Google Gemini or xAI's Grok,
in many cases, when talking about
such large language models,
we're referring to those AI chatbots.
And LM Studio is no exception.
It's an AI chatbot just using our locally running model,
but that's not the only way of using large language models.
Another very powerful and popular way
of using these large language models
is in your own applications,
your own tools,
applications you might be selling to your customers,
or any other kind of AI-powered application.
Because, of course, you can use these models to,
for example, parse user input,
to build a program that automatically analyzes images,
to build a program that automatically generates content.
The sky is the limit,
or your imagination is the limit.
And you can do that with those proprietary models as well.
For example, OpenAI also exposes their GPT models
through an API,
which you can consume programmatically,
and you can learn more about that
in their official documentation.
That's not the focus of this course,
but you can use these models programmatically.
That's the important takeaway.
And the same is true for those locally running models
when using LM Studio,
because LM Studio also exposes
a locally running large language model API server,
which you can access from inside your code
to communicate with those locally running models.
And that's exactly what we'll explore next.