Okay, so it seems like everyone is launching their own agent framework. Here, we've heard for the past couple of

months that 2023 is the year of agents, and certainly everyone's jumping in with their own take on how to make agents and

in this video, I want to talk about Smog Agents, which is a simple library to build agents from Hugging Face that just

got released last week. So, to be fair, this is not Hugging Face's first attempt at making an agent library.

Originally, they had the Transformers Agents, and I'm showing you here version two, which was May last year, but actually

version one, I think, was May 2022. So that's been around; it really didn't take

off, I think, for a number of different reasons. And Hugging Face seems to have come back and rethought this, and to be

fair, they've rethought this in light of a lot of other frameworks coming out, and people now seeing what works, what

doesn't work, where things get really complicated, where things are just too simple—all these sorts of things people

have been trying to work out over the past 18 months plus for building agents. So, Smog Agents from Hugging Face is

certainly an interesting library. It's got a number of key things that sort of set it apart that I'm going to go

through here, and then we'll have a look in Colab at simple examples of code of how you can get started to try this

out, etc. So, one of the big advantages that Hugging Face has, which they're now sort of really taking advantage of here,

is that they've got all these open-source models on their Hugging Face Hub, and this framework allows you to use

any of those models. So they've actually got it set up so that you can basically call the models on the Hub. Now, you will

be limited a little bit to what models you can access, depending on whether you're a pro user, like a paid user,

or not, of Hugging Face. But certainly, out of the box, it seems that they're using the LLaMA 2 7B, 13B

billion models. So that's definitely a good model that you can use to get started with this, although I imagine a

lot of people are going to want to be able to use things like DeepSpeed, CodeLlama, and stuff like that. Now you can use

proprietary models in here. I will talk about that as well. If you want to use OpenAI, if you want to use Anthropic's

Claude, etc., all those things are possible in here. So let's jump in and have a look.

So first off, they start off talking about what agents are, and I feel like this is getting to be quite repetitive,

but certainly we're now starting to have people converge on definitions of what these are. So they talk about the whole

idea of agency, of the sort of ability to take action in here. And I would say that this is one of the sort of key things

that we've been seeing different frameworks approach this idea of agency in different ways. So if we go right back

to things like BabyAGI and Auto-GPT, etc., the challenge with those was that they had too much agency in that they decided

everything themselves. They often didn't have tools at the start. Even when they did have tools, they were just randomly

almost randomly going out there and taking actions, and this just meant a huge bill for the amount of tokens, etc. Then on the

other hand, we have frameworks like LangChain, which really try to restrict the agency of an agent so that it can only

do things that are on rails, and that in 2024 showed to be the much safer way to build agents, the much more reliable way

To build agents, we're now moving into the next phase, as the models have gotten a lot better over the last year, where

people are now starting to think, okay, maybe we can give some of the agency back to these agents that we're building

in here. So they've got this nice sort of description here of the agency level of what these sort of mean, and then how

that's called, right? Whether that's basically you're giving them tool calls, so tools, whether you've got multi-step

agents where they're going in a loop, where you've got multiple agents going on here. And you can imagine with things

like multiple agents, we've seen that being done with things like ChainAI, with Llama AI, with a bunch of other things that

are out there as well. And I think the big debate at the moment around agents is really, do you really even need any

sort of sophisticated framework? You can basically just use something that's very light, like LangChain, to do your calls,

you can write all your tools and functions and stuff like that in pure Python, and it does seem that the idea

here is that SmogAgents is trying to place itself in the middle of this, of where you can go both ways for this now.

They do have a graphic here of an agent running in a loop where it's doing, executing different tools or different

things at each step. And this is on the upper level of how much agency do you want to give an agent going through here,

and you can see that a lot of the patterns that they use in here are very similar to things like the React pattern,

which I think I made a video for almost two years ago. So a lot of those sorts of things haven't changed. They have a whole

section in their blog post about when to use agents, when to avoid agents. I certainly would concur with most of what

They've got in here that for a lot of things, people do not need agents; people are making a big deal about things that

can just be done as a simple workflow. If you haven't seen the recent Anthropic blog post all about that, I recommend you

go and read that. I've put a video all about that, with some code examples and stuff, on my Patreon for people who are

more interested in that. But really, the only times you want to use agents are when you've got some kind of dynamic

decision-making that's happening in this flow, and the flow can change directions—right? It can go off in different angles

and stuff like that. So the big thing that sets Smog agents apart from other frameworks that are out there is this

whole idea of code agents; is that they're really going back to the idea of getting the agents to communicate with

itself in code and work things out in code. Now, they mentioned some research papers to justify this, well, that one of

the ones that I didn't see that they've included there is actually the PAL program AED language model, and this goes

back to 2022. The latest version of the paper, I think, is early 2023, but originally this came out in 2022. I did a

video about this—again, we're coming up on close to two years ago—of the idea of getting the LM to write code and then

use that to help it. Now that has been advanced a lot in papers like this Code Act paper—right?—the executive code

actions paper. And what that paper really showed us was that often it's going to be better to get the model to use

something like Python to execute code and adjust any feedback with that. So this doesn't totally eliminate text and

JSON, etc. You can still put those things in there, but it also allows you then to be able to pass back other objects. It

also allows you to take advantage of a lot of these models that are being trained for coding use now, so I think

this is a really interesting direction that Hugging Face has gone in here, and that the Smog Agents team has gone

here is looking at incorporating. So they've actually got sort of code agents and tool-calling agents in here. Okay,

some other things, just quickly: they really emphasized this idea of first-class support for these code agents; that these are thinking in or writing their

actions in code. And one of the good things with that is that can be run in a sandboxed environment, so it looks like

out of the gate they're already supporting e2e, which is a nice way for running sandboxed code for LLM apps and

agents, etc. But they do also mention in here that on top of the code agents, they still are supporting the tool-calling

agent, so you can use that if you want to. Finally, I mentioned earlier that about the Transformer agents, they

do I refer to this as being the successor to Transformer agents, and that Transformer agents will be deprecated

going forward. So if we have a look at how they build these agents, one of the cool things is you don't require a large

amount of code to get going. So you can see from `smog_agents` we're importing the `CodeAgent`, the `DuckDuckGoSearch` tool,

and we're importing this Hugging Face API model. So really, what that is just going to be able to use Hugging Face models by

calling their API, uh, in there. And you can see we just instantiate that as a model in here, pass in the tool, and then

we can pass something in, and we will get our response back. It will decide whether it needs to do multiple steps in there;

it will decide what tool to call based on what tools you put in there, etc., as you go through. So to get this going,

Really, you basically just need to pass in a model and some tools. And, like I mentioned earlier, if you don't

want to use one of the Hugging Face models, you can always use LLMs to be able to use things like OpenAI,

Claude, Anthropic, etc. Now, they have an example in the blog post of basically making a custom tool for this using the

Google Maps API, and this looks just like a basically a normal tool that you would define in most agent frameworks

out there. Now, in that you would use the docstring to basically tell it that you're using args, etc. In this case,

you've got your imports in there; it's going to run through using this API and then return back, in this case, just the

text from that API call. And we can see that to use this, we've got a `CodeAgent` where we're just passing in this custom

tool, passing in the model that we want to use. And one of the cool things is that we can also pass in this idea of

additional authorized imports. So, just like we would want to restrict what Python packages get used in our sandbox, we can actually tell it that, okay, apart

from just using standard Python, you can also use `datetime` in this. And you'll see in some examples in the Colab that

you can pick to use things like pandas, Beautiful Soup, if you want to have it automatically do some scraping and stuff

like that. So you can make use of that sandbox Python environment to have the code agent run various things that are

in there. All right, let's jump into the code and have a play with the code and see how it works actually in Colab. All

right, so if we come into the code, you'll see that this is pretty easy to set up. So they've got a Python package

for `smolagents`. If you want to use proprietary models or external models that are not in the Hugging Face

ecosystem, you can use light LMs in there because I'm going to be showing you using the GPT-4 OpenAI model. I'm bringing in

a key for that as well. You will need a Hugging Face token key, or you will need to manually log in. That's because you're

going to be using their API for the actual LLM calls, so you'll see that when we start out. Like this one

of the big things we're doing is bringing in this HF API model. So this basically just means that we're going to

be using a model from the Hugging Face Hub. Now remember, these are not necessarily models that are made by

Hugging Face. In fact, the model that we're going to be using by default is going to

be the Qwen-2.5-Code-32B instruction model in here. But if you want to set the

model, you would basically pass that in here as an argument. Now to do that, that's why you need the Hugging Face

token coming in here. All right, so to get up a simple agent—unbelievably simple, right?—we just literally do `from smolagents`

we're importing the `CodeAgent`; we're importing a tool, in this case, `DuckDuckGoSearchTool`; and we're bringing

smolagents - HuggingFace's NEW Agent Framework

HI my name is Sam Witteveen, I have worked with Deep Learning for 9 years and with Transformers and LLM for 5+ years.  I was appointed a Google Developer Expert for Machine Learning in 2017 and I currently work on LLMs and and since earlier in 2023 on Autonomous Agents. 

Sam Witteveen

Hugging Face의 새로운 에이전트 프레임워크 Smog Agents 소개 및 기존 프레임워크와의 비교

2023년을 에이전트의 해로, 다양한 에이전트 프레임워크 출시 현황 언급

Hugging Face의 새로운 에이전트 프레임워크 Smog Agents 소개 및 최근 출시 사실 언급

Hugging Face의 이전 에이전트 라이브러리인 Transformers Agents 언급 및 그 한계점 지적

Smog Agents의 주요 특징 및 차별점 소개

Hugging Face Hub의 오픈소스 모델 활용 가능성 및 유료 사용자와의 차이점 설명

에이전트의 개념 및 다양한 에이전트 프레임워크의 접근 방식 비교

에이전트의 정의 및 개념에 대한 설명

다양한 프레임워크에서 에이전트의 'agency' 개념에 대한 접근 방식 비교 (BabyAGI, Auto-GPT, LangChain 등)

최근 모델 발전에 따른 에이전트의 agency 수준 변화 및 향후 방향 제시

에이전트 프레임워크의 필요성에 대한 논의 및 Smog Agents의 위치 설명

Smog Agents의 핵심 기능: 코드 에이전트 및 그 장점

Smog Agents의 코드 에이전트 개념 설명 및 관련 연구 언급 (PAL, Code Act 등)

코드 에이전트의 장점: Python 코드 실행 및 객체 전달을 통한 유연성 증대

샌드박스 환경 지원 및 코드 에이전트와 툴 호출 에이전트의 병행 지원

Transformers Agents의 후속 프레임워크로서의 Smog Agents 위치 설명

Smog Agents 사용 예시 및 코드 설명

간단한 코드 예시를 통한 Smog Agents 사용 방법 설명

Hugging Face 모델 외 OpenAI, Anthropic 등의 모델 사용 가능성 설명

Google Maps API를 활용한 사용자 지정 툴 생성 예시

샌드박스 Python 환경에서 pandas, Beautiful Soup 등의 라이브러리 사용 방법 설명

Colab을 이용한 실제 코드 실행 및 결과 분석

Colab 환경 설정 및 Hugging Face API 모델 사용 방법 설명

간단한 에이전트 생성 및 실행 예시 (Qwen-2.5-Code-32B 모델 사용)

복잡한 질문에 대한 에이전트의 응답 및 코드 실행 과정 분석 (예: 멜버른-시드니 운전 시간 계산)

라이브러리 사용 제한 및 에러 처리 과정 설명

모델 변경 및 라이브러리 추가를 통한 에이전트 성능 개선 시도

독점 모델 사용 방법 및 추가 라이브러리 사용 설정

시스템 프롬프트 변경 및 로그 분석

시스템 프롬프트 확인 및 사용자 지정 방법 설명

로그 확인 및 에이전트 동작 분석

메모리 기능을 이용한 에이전트 동작 기록 및 요약

사용자 지정 툴 생성 및 Hugging Face Hub에 업로드 기능 소개

smolagents - HuggingFace's NEW Agent Framework

smolagents - HuggingFace's NEW Agent Framework

스크립트