Replicated

RasterizerState, SampleState, BlendState

라구넹 — Sat, 1 Aug 2026 22:49:25 +0900

1. RasterizerState

void Game::CreateRasterizerState()
{
	D3D11_RASTERIZER_DESC desc;
	ZeroMemory(&desc, sizeof(desc));
	desc.FillMode = D3D11_FILL_SOLID;
	desc.CullMode = D3D11_CULL_BACK;
	desc.FrontCounterClockwise = false;

	HRESULT hr = _device->CreateRasterizerState(&desc, _rasterizerState.GetAddressOf());
	CHECK(hr);
}

이래놓고 키면 별 차이 없음

D3D11_FILL_WIREFRAME

이걸로 하면

안을 안채움

CullMode는 안보이는 거 잘라내는 건데

BACK은 후면이면 잘라낸다는 거

D3D11_CULL_FRONT

전면을 잘라내니 당연히 안보임

앞 뒤 판별은 어떻게 되느냐

FrontCounterClockwise

카운터클록와이즈, 반시계

앞방향이 반시계 방향이다 라는 설정이 false

삼각형을 만들 때, 정점 설정을 시계 방향으로 했음. 그래서 이게 앞면이 됨

2. SampleState

Texture2D texture0 : register(t0); 
SamplerState sampler0 : register(s0);

float4 PS(VS_OUTPUT input) : SV_Target
{
    float4 color = texture0.Sample(sampler0, input.uv);
    return color;
}

여기서 썼던 건데

uv 좌표 따라서 샘플링 해주는 거와 관련

샘플링 규칙

void Game::CreateSamplerState()
{
	D3D11_SAMPLER_DESC desc;
	ZeroMemory(&desc, sizeof(desc));
	desc.AddressU = D3D11_TEXTURE_ADDRESS_BORDER;
	desc.AddressV = D3D11_TEXTURE_ADDRESS_BORDER;
	desc.AddressW = D3D11_TEXTURE_ADDRESS_BORDER;
	desc.BorderColor[0] = 1;
	desc.BorderColor[1] = 0;
	desc.BorderColor[2] = 0;
	desc.BorderColor[3] = 1;
	desc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
	desc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
	desc.MaxAnisotropy = 15;
	desc.MaxLOD = FLT_MAX;
	desc.MinLOD = FLT_MIN;
	desc.MipLODBias = 0.0f;

	_device->CreateSamplerState(&desc, _samplerState.GetAddressOf());
}

근데 이래도 잘 안보이니까

버텍스 UV 수정 좀 해주면

이런식으로 되는데

D3D11_TEXTURE_ADDRESS_BORDER

이거 때문

desc.AddressU = D3D11_TEXTURE_ADDRESS_MIRROR;
desc.AddressV = D3D11_TEXTURE_ADDRESS_BORDER;
desc.AddressW = D3D11_TEXTURE_ADDRESS_BORDER;

U만 미러하면 이런식

이런식으로 샘플링에 관련된 것들 세팅 가능

3. BlendState

void Game::CreateBlendState()
{
	D3D11_BLEND_DESC desc;
	ZeroMemory(&desc, sizeof(desc));
	desc.AlphaToCoverageEnable = false;
	desc.IndependentBlendEnable = false;

	desc.RenderTarget[0].BlendEnable = true;
	desc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
	desc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_DEST_ALPHA;
	desc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
	desc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
	desc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
	desc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
	desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;

	HRESULT hr = _device->CreateBlendState(&desc, _blendState.GetAddressOf());
	CHECK(hr);
}

그냥 블렌드 설정

Constant Buffer

라구넹 — Sat, 1 Aug 2026 21:47:04 +0900

결국 게임이니 버텍스 위치가 바뀌어야 하는데

D3D11_USAGE_IMMUTABLE

이전에 썼던 이건 리드 온리임

모양 자체는 어떤 기준점을 보고 기하학적 형태는 불변한 경우가 많음. 스태틱 메시 같은?

기하학적인 도형은 냅두고 버텍스 쉐이더에서 이동시키면 간단하게 끝남

cbuffer TransformData : register(b0)
{
    float4 offset;
}

VS_OUTPUT VS(VS_INPUT input)
{
    VS_OUTPUT output;
    output.position = input.position + offset;
    //output.color = input.color;
    output.uv = input.uv;
    
    return output;
}

버퍼 0번 슬롯에 연결해두고

void Game::Update()
{
	_transformData.offset.x = 0.3f;
	_transformData.offset.y = 0.3f;

	D3D11_MAPPED_SUBRESOURCE subResource;
	ZeroMemory(&subResource, sizeof(D3D11_MAPPED_SUBRESOURCE));

	_deviceContext->Map(_constantBuffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &subResource);
	::memcpy(subResource.pData, &_transformData, sizeof(_transformData));
	_deviceContext->Unmap(_constantBuffer.Get(), 0 );
}

업데이트에서 CPU데이터인 트랜스폼 데이터를 콘스턴트 버퍼에 넣어두고

_deviceContext->VSSetConstantBuffers(0, 1, _constantBuffer.GetAddressOf());

렌더에서 0번 버퍼 슬롯에 연결

이동했다

텍스처, UV

라구넹 — Sat, 1 Aug 2026 18:08:27 +0900

인덱스 버퍼

정점들 미리 정의해두고 인덱스로 넘기면 효율적이니까 사용

버텍스는 무겁다

void Game::CreateGeometry()
{
	{
		_vertices.resize(4);

		/*
		* 13
		* 02
		*/

		_vertices[0].position = Vec3(-0.5f, -0.5f, 0.0f);
		_vertices[0].color = Color(1.0f, 0.0f, 0.0f, 1.0f);

		_vertices[1].position = Vec3(-0.5f, 0.5f, 0.0f);
		_vertices[1].color = Color(0.0f, 1.0f, 0.0f, 1.0f);

		_vertices[2].position = Vec3(0.5f, -0.5f, 0.0f);
		_vertices[2].color = Color(0.0f, 0.0f, 1.0f, 1.0f);

		_vertices[3].position = Vec3(0.5f, 0.5f, 0.0f);
		_vertices[3].color = Color(0.0f, 0.0f, 1.0f, 1.0f);
	}

	// Vertex Buffer
	{
		D3D11_BUFFER_DESC desc;
		ZeroMemory(&desc, sizeof(desc));
		desc.Usage = D3D11_USAGE_IMMUTABLE;	// GPU Read Only
		desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
		desc.ByteWidth = static_cast<uint32>( sizeof(Vertex) * _vertices.size() );

		D3D11_SUBRESOURCE_DATA data;
		ZeroMemory(&data, sizeof(data));
		data.pSysMem = &_vertices[0];

		_device->CreateBuffer(&desc, &data, _vertexBuffer.GetAddressOf());
	}

	// Index
	{
		_indices = { 0, 1, 2, 2, 1, 3 };

	}

	// Index Buffer
	{
		D3D11_BUFFER_DESC desc;
		ZeroMemory(&desc, sizeof(desc));
		desc.Usage = D3D11_USAGE_IMMUTABLE;	// GPU Read Only
		desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
		desc.ByteWidth = static_cast<uint32>(sizeof(uint32) * _indices.size());

		D3D11_SUBRESOURCE_DATA data;
		ZeroMemory(&data, sizeof(data));
		data.pSysMem = &_indices[0];

		HRESULT hr = _device->CreateBuffer(&desc, &data, _indexBuffer.GetAddressOf());
		CHECK(hr);
	}
}

인덱스 버퍼 만들고

void Game::Render()
{
	RenderBegin();

	{
		uint32 stride = sizeof(Vertex);
		uint32 offset = 0;

		// IA
		_deviceContext->IASetVertexBuffers(0, 1, _vertexBuffer.GetAddressOf(), &stride, &offset);
		_deviceContext->IASetIndexBuffer(_indexBuffer.Get(), DXGI_FORMAT_R32_UINT, 0);
		_deviceContext->IASetInputLayout(_inputLayout.Get());
		_deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

		// VS
		_deviceContext->VSSetShader(_vertexShader.Get(), nullptr, 0);

		// RS

		// PS
		_deviceContext->PSSetShader(_pixelShader.Get(), nullptr, 0);

		// OM
		//_deviceContext->Draw(_vertices.size(), 0);
		_deviceContext->DrawIndexed(_indices.size(), 0, 0);
	}

	RenderEnd();
}

IASetIndexBuffer

로 인덱스 버퍼 넣어주고

DrawIndexed

로 그려주면

이렇게 됨

결국 인덱스 버퍼는 정점 개수 메모리에 올라가는 거 줄일 수 있으니 이득

뭐 아무튼 이런 거에 실제 이미지를 넣을 수 있어야 함

이미지 파일에서 좌표를 꺼내야 함

-> uv 필요

uv는 0~1 사이의 값으로 이미지 매핑하는 것

_vertices[0].position = Vec3(-0.5f, -0.5f, 0.0f);
_vertices[0].uv = Vec2(0.0f, 1.0f);
//_vertices[0].color = Color(1.0f, 0.0f, 0.0f, 1.0f);
		
_vertices[1].position = Vec3(-0.5f, 0.5f, 0.0f);
_vertices[1].uv = Vec2(0.0f, 0.0f);
//_vertices[1].color = Color(0.0f, 1.0f, 0.0f, 1.0f);

_vertices[2].position = Vec3(0.5f, -0.5f, 0.0f);
_vertices[2].uv = Vec2(1.0f, 1.0f);
//_vertices[2].color = Color(0.0f, 0.0f, 1.0f, 1.0f);

_vertices[3].position = Vec3(0.5f, 0.5f, 0.0f);
_vertices[3].uv = Vec2(1.0f, 0.0f);
//_vertices[3].color = Color(0.0f, 0.0f, 1.0f, 1.0f);

UV 순서대로 맞춰서 넣고

VS_OUTPUT VS(VS_INPUT input)
{
    VS_OUTPUT output;
    output.position = input.position;
    //output.color = input.color;
    output.uv = input.uv;
    
    return output;
}

Texture2D texture0 : register(t0); 
SamplerState sampler0 : register(s0);

float4 PS(VS_OUTPUT input) : SV_Target
{
    float4 color = texture0.Sample(sampler0, input.uv);
    return color;
}

쉐이더도 수정해주고

void Game::CreateSRV()
{
	DirectX::TexMetadata md;
	DirectX::ScratchImage img;

	HRESULT hr = ::LoadFromWICFile(L"bubble.png", WIC_FLAGS_NONE, &md, img);
	CHECK(hr);

	hr = ::CreateShaderResourceView(_device.Get(), img.GetImages(), img.GetImageCount(), md, _shaderResourceView.GetAddressOf());
	CHECK(hr);


}

SRV도 만들어주고

_deviceContext->PSSetShaderResources(0, 1, _shaderResourceView.GetAddressOf());

SRV 세팅해주면

잘 된다

샘플러 스테이트 같은 걸 설정하면 uv 초과하거나 등등의 상황에 대해 옵션 지정 가능

삼각형 띄우기

라구넹 — Sat, 1 Aug 2026 01:33:29 +0900

void Game::Init(HWND hand)
{
	_hwnd = hand;
	_width = GWinSizeX;
	_height = GWinSizeY;

	CreateDeviceAndSwapChain();
	CreateRenterTargetView();
	SetViewPort();

	CreateGeometry();
	CreateVS();
	CreateInputLayout();
	CreatePS();
}

CreateGeometry : 정점 데이터 -> GPU 버퍼

CreateVS : 버텍스 쉐이더 로드

CreateInputLayout..

D3D11_BUFFER_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.Usage = D3D11_USAGE_IMMUTABLE;	// GPU Read Only
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.ByteWidth = static_cast<uint32>( sizeof(Vertex) * _vertices.size() );

D3D11_SUBRESOURCE_DATA data;
ZeroMemory(&data, sizeof(data));
data.pSysMem = &_vertices[0];

_device->CreateBuffer(&desc, &data, _vertexBuffer.GetAddressOf());

Usage : IMMUTABLE은 한 번 만들고 안바꿈 -> GPU 리드 온리

pSysMem은 초기 데이터의 출처

void Game::CreateInputLayout()
{
	D3D11_INPUT_ELEMENT_DESC layout[] =
	{
		{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
		{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
	};

	const int32 count = sizeof(layout) / sizeof(D3D11_INPUT_ELEMENT_DESC);
	_device->CreateInputLayout(layout, count, _vsBlob->GetBufferPointer(), _vsBlob->GetBufferSize(), _inputLayout.GetAddressOf());
}

결국 그래봐야 바이트 덩어리라 레이아웃 맞춰줘야 함

void Game::CreateVS()
{
	LoadShaderFromFile(L"Default.hlsl", "VS", "vs_5_0", _vsBlob);

	HRESULT hr = _device->CreateVertexShader(_vsBlob->GetBufferPointer(), _vsBlob->GetBufferSize(), nullptr, _vertexShader.GetAddressOf());
	CHECK(hr);
}

void Game::CreatePS()
{
	LoadShaderFromFile(L"Default.hlsl", "PS", "ps_5_0", _psBlob);

	HRESULT hr = _device->CreatePixelShader(_psBlob->GetBufferPointer(), _psBlob->GetBufferSize(), nullptr, _pixelShader.GetAddressOf());
	CHECK(hr);
}

void Game::LoadShaderFromFile(const wstring& path, const string& name, const string& version, ComPtr<ID3DBlob>& blob)
{
	const uint32 compileFlag = D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;

	HRESULT hr = ::D3DCompileFromFile(
		path.c_str(),
		nullptr,
		D3D_COMPILE_STANDARD_FILE_INCLUDE,
		name.c_str(),
		version.c_str(),
		compileFlag,
		0,
		blob.GetAddressOf(),
		nullptr
	);

	CHECK(hr);
}

ID2DBlob은 그냥 바이트 덩어리고 여기에 쉐이더 바이트 코드가 담김

장치 초기화

라구넹 — Sat, 1 Aug 2026 00:27:02 +0900

ComPtr< ID3D11Device > _device;
ComPtr< ID3D11DeviceContext > _deviceContext;
ComPtr< IDXGISwapChain > _swapChain;

_device : 리소스 생성

_deviceContext : GPU에 명령 발행

_swapChain : 화면 출력

void Game::Init(HWND hand)
{
	_hwnd = hand;
	_width = GWinSizeX;
	_height = GWinSizeY;

	CreateDeviceAndSwapChain();
	CreateRenterTargetView();
	SetViewPort();
}

초기화 진입점.

순서는 강제. 스왑체인이 있어야 백버퍼를 꺼낼 수 있고, 백버퍼가 있어야 RTV(Render Target View)를 만들 수 있음

void Game::CreateDeviceAndSwapChain()
{
	DXGI_SWAP_CHAIN_DESC desc;
	ZeroMemory(&desc, sizeof(desc));

	{
		desc.BufferDesc.Width = _width;
		desc.BufferDesc.Height = _height;
		desc.BufferDesc.RefreshRate.Numerator = 60;
		desc.BufferDesc.RefreshRate.Denominator = 1;
		desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
		desc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
		desc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
		desc.SampleDesc.Count = 1;
		desc.SampleDesc.Quality = 0;
		desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
		desc.BufferCount = 1;
		desc.OutputWindow = _hwnd;
		desc.Windowed = true;
		desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
	}

	HRESULT hr = ::D3D11CreateDeviceAndSwapChain(
		nullptr,
		D3D_DRIVER_TYPE_HARDWARE,
		nullptr,
		0,
		nullptr,
		0,
		D3D11_SDK_VERSION,
		&desc,
		_swapChain.GetAddressOf(),
		_device.GetAddressOf(),
		nullptr,
		_deviceContext.GetAddressOf()
	);

	CHECK(hr);
}

디바이스, 디바이스 컨텍스트, 스왑체인 생성

desc 밀어버리는 건 DX가 쓰레기값 진짜값으로 오인하는 경우가 있음

DXGI_SWAP_CHAIN_DESC

- 인자용 구조체

- Width, Height : 백버퍼 해상도로 창 크기와 별개

- RefreshRate : 주사율, 전체 화면에서만 유효

- Format : 픽셀 저장 방식

- Count : 픽셀 당 샘플 수로 1 = MSAA 끔. 안티 앨리어싱 관련 필드

- BufferUsage : 버퍼 용도 선언

- BufferCount : 백버퍼 개수

- OutputWindow : 출력 대상 윈도우

- SwapEffect : 프레젠트 후 백버퍼 처리 방식

RefreshRate가 분수인건 실제 모니터가 59.94Hz ( 60000/1001 )같은 값이라..

DXGI_FORMAT_R8G8B8A8_UNORM

- 채널당 8비트로 총 32비트

desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;

이 버퍼는 렌더링 용이다 미리 정해놔야 GPU가 세팅함

desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;

화면에 직접 그리면 그려지는 과정이 보여서 티어링 생기니까 백버퍼에 완성하고 교체하는데

디스카드는 교체 후 이전 내용을 버린다는 뜻

D3D_DRIVER_TYPE_HARDWARE

GPU 하드웨어 가속

void Game::CreateRenterTargetView()
{
	HRESULT hr;

	ComPtr<ID3D11Texture2D> backBuffer = nullptr;
	hr = _swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)backBuffer.GetAddressOf());
	CHECK(hr);

	hr = _device->CreateRenderTargetView(backBuffer.Get(), nullptr, _renderTargetView.GetAddressOf());
	CHECK(hr);

}

1. 백버퍼(리소스) 꺼내기

스왑체인이 내부적으로 들고 있는 백버퍼를 꺼냄

__uuidof는 이 인터페이스로 달라는 요청.

2. 뷰 만들기

리소스는 뷰와 다름. GPU는 리소스에 직접 접근하지 않고 항상 뷰를 통해 접근

리소스: 실제 픽셀이 담긴 메모리 덩어리, 백버퍼

렌더 타겟 뷰 : 해당 메모리를 렌더 타겟으로 해석하라는 설명서

같은 텍스처 하나를 이번 패스에선 그릴 대상(RTV)로, 다음 패스에선 셰이더가 읽는 텍스처(SRV)로 쓸 수 있음

그때마다 다른 뷰를 만들어 끼움

뷰	의미
RTV (Render Target View)	여기다 그린다
SRV (Shader Resource View)	셰이더에서 읽는다
DSV (Depth Stencil View)	깊이, 스텐실 판정
UAV (Unordered Accessn View)	셰이더에서 읽고 쓴다

void Game::RenderBegin()
{
	_deviceContext->OMSetRenderTargets(1, _renderTargetView.GetAddressOf(), nullptr);
	_deviceContext->ClearRenderTargetView(_renderTargetView.Get(), _clearColor);
	_deviceContext->RSSetViewports(1, &_viewport);
}

매 프레임 렌더 준비

함수 접두사 == 파이프라인 단계

단계

IA (Input Assembler)

VS (Vertex Shader)

RS (Rasterizer)

PS (Pixel Shader)

OM (Output Shader)

void Game::RenderEnd()
{
	HRESULT hr = _swapChain->Present(1, 0);
	CHECK(hr);
}

완성된 백버퍼 화면과 교체

첫 인자는 VSync, 수직 동기화임

MatchMaking Svr #1 : UDP Hole Punching + Relay Fallback

라구넹 — Mon, 20 Apr 2026 23:52:53 +0900

https://github.com/Lagooneng/MatchMakingSvr

GitHub - Lagooneng/MatchMakingSvr: C++ TURN-like matchmaking svr (UDP Hole-Punching + UDP relay fallback)

C++ TURN-like matchmaking svr (UDP Hole-Punching + UDP relay fallback) - Lagooneng/MatchMakingSvr

github.com

언리얼 엔진 OSS 디버깅 안되는 거 너무 불편해서 그냥 매치메이킹 서버를 만들고자 시도 중이다

UDP Hole Punching으로 직접 IP 알아내게 하고 실패 시 릴레이하게 해놨는데..

생각해보니 리슨 서버라 릴레이 하는 건 의미가 없긴 한 문제가 있다

언리얼을 데디로 싹 뜯어 고치거나 아니면 언리얼 네트워크 계층을 뜯어 고치거나..

아니면 다른 방법이 없나..? rnd를 좀 많이 해봐야겠다

RAG, MCP

라구넹 — Wed, 10 Dec 2025 00:55:18 +0900

검색 증강 생성(RAG)

- Retrieval-Agumented Generation

- LLM이 모든 지식이 있는 건 아니고 할로시네이션(환각)이 있음

- 효과적인 방법이 프롬프트 일부에 지식을 제공하는 것, 이 지식은 컨텍스트의 일부로서 입력됨

- 파인 튜닝보다 훨씬 적은 노력과 비용

- 정보의 변동성이 큰 분야에 효과적 대응 가능

- 최신 정보가 중요한 분야나 특정 도메인의 응용 프로그램에서 큰 강점

	RAG	Fine-tuning
정의	최신의 외부 데이터에서 적절한 문서 검색 및 답변을 생성해 LLM 모델의 정확성과 신뢰성을 향상시키는 방식	사전 학습된 모델에 각 개별 기업의 도메인 특화 데이터를 추가 학습시켜 맞춤형 모델로 업데이트 하는 방식
이점	외부 데이터에 대한 상시적 접근 가능 데이터의 최신성 유지에 용이 근거가 확실한 데이터를 기반으로 답변 생성	양질의 라벨링 데이터만 있다면 높은 품질의 모델 생성 가능 업데이트가 빈번하지 않은 특정 도메인에서 유용
도전과제	관련 없는 문서를 검색할 가능성이 있어 효율적인 검색 모델을 구축해야 함	충분한 데이터가 없거나 양질의 데이터가 아닌 경우 모델의 퀄리티가 낮아질 수 있음 모델의 지식은 마지막 훈련 데이터까지만 한정됨
유스케이스	새로운 데이터가 자주 업데이트 되는 기업	특정 작업용 애플리케이션

Indexing

RAG 시스템 구축의 첫 단계, 프롬프트에게 제공할 지식 데이터베이스를 구축하는 단계

1. 문서 분할

- 대량의 텍스트 데이터를 관리하기 쉬운 작은 단위로 분할

- 이렇게 나눈 작은 단위를 청크라 함

2. 임베딩

- 각 청크를 컴퓨터가 이해할 수 있는 형태로 변환

- 자연어 처리 모델로 청크를 벡터로 변환하고, 이후 텍스트 간의 유사성을 계산하는데 활용

3. 저장

- 완성된 임베딩 벡터들을 효율적으로 저장하고 검색할 수 있는 벡터 데이터베이스에 보관

Retrieval

사용자 프롬프트와 연관성이 있는 지식을 벡터 데이터베이스에서 검색하여 가져오는 과정

1. 질문 임베딩

- 사용자의 질문(프롬프트)을 벡터로 변환, 문서 청크들과 비교 가능해짐

2. 유사성 비교

- 이 질문 벡터와 저장된 문서 청크 벡터 간의 유사성 계산

- 주로 사용되는 방법은 코사인 유사도나 유클리디안 거리 등의 수학적 척도

- 코사인 유사도: 두 벡터의 내적을 두 벡터 길이의 곱으로 나눈 값

3. 관련 문서 선택

- 유사도 점수를 바탕으로 가장 높은 상위 k개의 문서 청크를 선택

Generation

검색된 문서 청크는 원래의 질문과 결합되어 추가 컨텍스트를 형성

결합된 텍스트와 질문은 모델에 입력되어 최종 답변을 생성하는데 사용

RAG의 종류

- Naive RAG

- Advanced RAG

- Modular RAG

* FAISS

- 대용량 벡터 검색 라이브러리

- 페이스북에서 개발 및 배포한 밀집 벡터의 유사도 측정과 클러스터링에 효율적인 라이브러리

* RAG을 사용하면 LLM의 답변 속도가 현저히 느려질 수 있음

성능 최적화를 위해

- 문서 길이 제한 및 요약

- 임베딩 성능 개선

- 캐시 사용

- LLM 로딩 최적화

Vector database

llm이 정보를 효율적으로 검색하고 처리할 수 있도록 지원

속성 유사성으로 결과를 제공하는 의미론적 검색 어플리케이션에서 특히 중요

LangChain의 문서 관리 도구

- Document Loader가 다양한 소스에서 문서를 불러오고 처리하는 과정을 담당

- 주요 목적은 효율적으로 문서 데이터를 수집하고 사용 가능한 형식으로 변환하는 것

벡터 데이터베이스

- 벡터 형식의 데이터를 저장, 쿼리하고 분석하는데 특화된 데이터베이스

- 벡터 저장, 유사성 측정, 인덱싱, 쿼리 처리, 스케일링

- Pinecone, Chroma, Weviate, Milvus, Faiss, Qdrant..

- Chroma는 LLM 앱을 위한 최적화가 있음

벡터 DB 선택 시 고려 사항

- 확장성: 데이터 증가에 따른 성능 유지 가능 여부

- 검색 성능: 유사도 기반 검색 정확도와 속도

- 유연성: 다양한 데이터 형식, 모델과의 연동

- 사용 편의성: API, 문서화, 배포의 난이도

- 신뢰성: 오픈소스 커뮤니티 또는 상용 지원 여부

Chroma

- RAG 구축 시 많이 사용되는 오픈소스 벡터 데이터베이스

- 벡터 임베딩을 다루기 위한 다양한 기능 지원 (문서 및 질의 임베딩, 메타데이터 저장, 검색)

- 단순한 사용성, 유사도 순위 제공, 빠른 실행

MCP (Model Context Protocol)

- llm과 외부 데이터 소스 및 앱 간 안전하고 표준화된 상호작용을 정의하는 개방형 프로토콜

- 기존의 API 연동 방식이 모델마다, 도구마다 개별적으로 필요했던 복잡성을 해소하고 llm 기반 애플리케이션 개발과 확장성과 신뢰성을 높이는 것을 목표로 함

MCP vs tool calling

- MCP는 도구의 발견, 연결, 호출, 보안을 위한 표준화된 통신 및 아키텍처

- Tool Calling은 llm이 도구를 사용하도록 만드는 언어

구분	Tool Calling	MCP
개념적 역할	llm의 의도 파악 및 도구 사용 결정 언어	llm과 외부 도구, 데이터 간 표준 통신 인프라
핵심 기능	1. 모델이 호출할 함수의 JSONSchema 이해 2. 사용자 요청에 따라 함수 호출 필요 여부 및 인수 결정	1. 외부 도구, 데이터의 발견 및 등록 표준화 2. 보안, 인증, 전송 규격 정의 3. 다양한 llm 간의 도구 재사용성 보장
구현 방식	llm 내부의 추론 과정에서 json 객체를 출력하여 호출 의도를 표현	Host - Client - Server 구조를 갖는 외부 프로토콜
상호 운용성	모델 제공 업체에 의해 정의된 특정 json 스키마에 의존	개방형 표준이므로 llm 종류와 무관하게 모든 mcp 규격을 따르는 도구를 사용 가능
보안/인증	보통 툴 콜링 자체는 보안을 안다루고 실제 호출은 별도의 api 키나 인증 방식으로 처리	보안 및 인증 메커니즘을 내제

MCP의 기본 아키텍처

호스트 애플리케이션

- 사용자가 상호작용하는 최종 인터페이스

- 사용자의 요청을 받아서 llm에 전달하고 최종 응답을 사용자에게 보여줌

MCP 클라이언트

- 호스트 애플리케이션 내부에 통합되어 있음

- llm과 mcp 서버 간의 통신을 관리

- llm이 도구를 사용해야 한다고 판단하면 이 클라이언트가 mcp 서버에 요청을 보냄

MCP 서버

- 실제 외부 기능이나 데이터 소스에 연결되는 로직을 포함

- 클라이언트로부터 mcp 규격에 맞는 요청을 받아 실제 작업을 수행하고 그 결과를 다시 클라이언트에 반환

MCP가 가져온 변화

툴 재사용성 증가

- 한 번 MCP 서버로 구현된 도구는 다양한 llm에서 코드 수정없이 재사용될 수 있음

보안 및 감사 용이

- MCP는 보안, 접근 제어, 감사 기록 등에 대한 명확한 규약을 포함하고 있어 기업 환경에서 llm 에이전트를 안전하게 배포 가능

에이전트 기능 확장

- llm 에이전트가 RAG을 넘어 복잡한 업무 자동화를 수행할 수 있게 되어 llm의 유틸리티를 극대화

MCP 개발 프레임워크

프로토콜 표준을 중심으로 다양한 서버 및 클라이언트 구현체가 존재

LangChain

- 기존의 에이전트 프레임워크로 MCP 서버를 도구처럼 활용할 수 있는 어댑터를 제공

smolagent (Hugging Face)

- 허깅 페이스의 LocalPythonExecutor와 함께 사용하여 MCP를 AI 어시스턴트와 통합 가능

GitHub MCP

- 코드 작성 지원을 위해 클로드와 협업하는 코딩 도우미 서버의 한 종류

FastAPI-MCP

- 개발자가 자신만의 MCP 서버를 쉽게 구축할 수 있도록 돕는 라이브러리

Cursor MCP Installer

- 개발 편의성을 위해 Cursor IDE에 MCP 서버를 자동으로 추가하는 도구

AI Agent, Context Engineering

라구넹 — Mon, 8 Dec 2025 02:15:28 +0900

AI 에이전트

- 사용자를 대신하여 작업을 수행하는 소프트웨어 시스템 또는 프로그램

- 자율적으로 행동하며 목표를 설정하고 계획을 세우고 작업을 실행하여 결과를 얻을 수 있음

- 능동형 AI

AI 에이전트의 주요 특징

- 자율성 : AI 에이전트는 사람의 개입없이 독립적으로 작업을 수행

- 목표 지향성 : 에이전트는 특정 목표를 설정하고 이를 달성하기 위해 노력

- 환경 인식 및 상호 작용 : 주변 환경을 인지하고 데이터를 수집하고 외부 환경과 상호 작용할 수 있음

- 학습 능력 : 에이전트는 학습을 통해 지속적으로 성능을 향상 가능

- 추론 및 의사 결정 : 복잡한 문제 해결 및 의사 결정을 수행

에이전트의 종류

Zero-shot ReAct

- 작업과 도구 설명을 보고 사용할 도구를 결정

- ReAct는 Reasoning + Acting

- Resoning은 생각(Chain-of-Thought, COT), Acting은 외부 도구 실행을 의미

- 가장 기본이 되는 에이전트 유형

Structured Input ReAct

- 인풋이 여러 개인 도구를 사용할 때 필요한 에이전트

Conversational

- 대화 + ReAct로 대화 히스토리 저장을 위한 메모리가 필요

Self-ask with search

- 인터넷 검색 후 답변하는 에이전트로 검색 도구가 필요

ReAct document store

- 문서 저장소 + ReAct로 문서 검색 도구가 필요

에이전트의 작업 절차

1. Input : 사용자가 에이전트에 작업 할당

2. Thought : 에이전트가 작업을 완수하기 위해 무엇을 할 지 생각

3. Action / Action Input : 사용할 도구를 결정하고 도구의 입력(함수의 입력값)을 결정

4. Observation : 도구의 출력 결과를 관찰

5. 관찰 결과 작업을 완료했다는 판단에 도달할 때까지 2~4 반복

AI Agent 프레임워크

- AI 에이전트 플랫폼은 자율 에이전트를 생성, 배포 및 관리할 수 있는 소프트웨어

- 일반적으로 코드가 필요 없는 도구로 일상 업무에서 반복되는 작업을 자동화하는데 도움

- 무언가를 하기 위한 단계별 프로세스를 만들 수 있다면 그것은 자동화될 수 있음

AI Agent 프레임워크 선택 시 고려 사항

- 다양한 LLM 및 소프트웨어 API와 쉽게 통합할 수 있는가

- 운영 비용이 적절한가

- AI 에이전트 플랫폼이 사용자의 개입 없이 복잡한 작업을 자동으로 실행할 수 있는가

- 처리 속도는 적절한가

- 적절한 보안 설정 및 관리가 가능한가

- 도움을 줄 수 있는 사용자 커뮤니티가 있는가

주요 프레임워크

LangChain & LangGraph

- 가장 대표적인 AI 에이전트 개발 프레임워크

- LLM을 활용하여 에이전트를 구축하는데 필요한 다양한 도구와 기능을 제공

CrewAI

- 파이썬 기반 오픈소스 프레임워크

- 여러 AI 에이전트들이 협력하여 문제를 해결하는 분산형 AI 에이전트의 구축을 지원

- 팀워크와 협업을 중시하는 AI 시스템에 적합

LlamdaIndex

- AI 에이전트가 데이터베이스나 다양한 외부 데이터소스를 처리하고 검색할 수 있도록 도와주는 프레임워크

- 검색 기반 AI 시스템이나 지식 관리 시스템을 구축하는데 유용

AutoGen

- 서로 다른 분야를 담당하는 네 가지 전문 에이전트와 이를 조율하는 오케스트레이터로 구성

- 다양한 산업에 즉시 적용할 수 있는 모듈을 바탕으로 반복적인 작업을 자동화하거나 대량의 데이터를 처리하는데 유용

Agent 개발에 자주 사용되는 LangChain 요소

모델

- OpenAI의 ChatGPT 등 여러 LLM 제공 업체와 연결하는 인터페이스를 제공

프롬프트

- LLM에 입력될 프롬프트를 구성하고 관리하는 PromptTemplate과 같은 도구를 포함

- 이는 모델의 출력을 제어하고 특정 작업에 맞게 지시하는데 중요

체인

- 일련의 구성 요소를 연결하여 복잡한 작업을 자동화하는 구조

- LLMChain, ConversationChain 등이 대표적

에이전트

- LLM을 추론 엔진으로 사용하여 어떤 도구를 사용할지 결정하고 일련의 관찰과 행동을 반복하며 목표를 달성하도록 설계된 고급 구성 요소

도구

- 언어 모델이 외부 세계와 상호작용하고 특정 작업을 수행할 수 있도록 지원

- 검색, DB, 파일 시스템, API, 사용자 정의 도구

메모리

- 대화 기록이나 이전 상호작용의 컨텍스트를 저장하고 검색하여 모델이 연속된 상호작용에서 일관된 응답을 할 수 있도록 돕는 역할

문서 로더 및 텍스트 분할기

- RAG 파이프라인에서 다양한 형식의 문서를 불러오고 처리하기 쉬운 작은 청크로 분할하는데 사용

리트리버

- 사용자 쿼리를 기반으로 가장 관련성이 높은 문서를 벡터 저장소 등에서 검색하는 구성 요소

LangChain Agents

- ReAct 기반 에이전트 개발을 지원

구성요소

- Agent : 의사 결정을 담당하는 핵심 컴포넌트

- Tools : 에이전트가 사용할 수 있는 기능들의 집합

- Toolkits : 관련된 도구들의 그룹

- AgentExecutor : 에이전트의 실행을 관리하는 컴포넌트

* ReAct

- Reasoning and Actng의 약자, 챗봇이 추론과 행동을 체계적으로 결합하여 문제를 해결하고 정보를 제공하는 프레임워크

핵심 기능

- 추론 : 모델이 문제 해결을 위해 필요한 계획을 유도하고 추적하며 업데이트할 수 있도록 함

- 헹동 : 외부 환경과 상호작용하여 필요한 정보를 수집하고 이를 바탕으로 작업을 수행

* RAG

- Retrieval-Augumented Generation (검색 증강 생성)

- llm이 답변을 생성할 때 외부 데이터베이스에서 관련 정보를 검색하여 이를 바탕으로 더 정확하고 최신 정보를 제공하게 하는 기술

- LLM이 학습한 시점 이후의 새로운 정보도 답변에 반영 가능

- 할로시네이션 줄여주고 출처를 제시해서 신뢰도를 높임

- LLM 자체를 재학습 시키는 대신 외부 데이터베이스만 업데이트하면 되므로 비용과 시간을 절약

- 특정 기업의 내부 문서 등 독점적인 정보를 활용하여 전문 분야에 맞는 답변을 제공 가능

Context Engineering

context : llm이 응답을 생성할 때 참고할 수 있는 입력 정보의 범위

context 구성 요소

- prompt : 사용자가 입력한 전체 텍스트

- system / instruction : 모델의 역할이나 스타일을 지정하는 초기 지침

- user / assistant messages : 이전 대화 내용

- rerieved docments(선택적) : RAG 등에서 외부 검색 결과를 추가하여 문맥 확장 가능

Context window

- LLM이 한 번에 처리할 수 있는 토큰의 최대 길이

요약

- Context Engineering은 대형 언어 모델의 성능을 극대화하기 위해 정보 환경을 체계적으로 설계하는 것
- 단순히 프롬프트를 최적화하는 Prompt Engineering을 넘어서는 개념

- 작업 수행에 필요한 전체 정보(시스템 지시사항, 대화 히스토리, 검색 문서, 출력 예약 공간 등)를 동적으로 조립 및 최적화하여 보다 정교하고 응답성 높은 AI 시스템을 구축할 수 있게 함

- 에이전트가 매 단계마다 필요한 정보만을 적절히 선택, 압축, 저장, 격리해서 llm의 컨텍스트 윈도우에 넣는 전략적 시스템 설계 작업

- 이를 통해 개발 생산성, 복잡한 응용 프로그램의 설계, AI 응용의 실질적인 효율성을 크게 향상 가능

항목	Prompt Engineering	Context Engineering
범위	단일 입력, 출력	전체 시스템 흐름, 메모리, 도구 통합
지속성	일회성	멀티턴, 세션 또는 장기 메모리
목표	명확한 지시	정황 환경 구성, 상태 유지
기술	문장 조정, 예시, few-shot	RAG, 스크래치패드, 동적 데이터, 툴 체인
스케일	소규모 테스트	실전 시스템, 다양한 유저 및 플로우

LangChain에서 제공하는 네가지 핵심 전략

- write : 정보를 외부 스크래치패드나 메모리에 기록

- select : 필요한 정보를 필요할 때 컨텍스트로 불러오기

- compress : 긴 기록은 요약 등으로 축소

- isolate : 서로 다른 주제는 분리 저장 등

1. Write : 컨텍스트를 어디에 남길 것인가?

- 사용자가 말한 중요한 내용을 에이전트가 직접 기억을 못하니 외부 메모리에 명시적으로 기록

- LangChain애서는 Memory, Dict, Scratchpad, Vector Stroe 등..

2. Select : 기억을 다 보여줄 필요는 없고 필요한 것만

- 기록해둔 많은 정보 중 꼭 필요한 정보만 선별해서 LLM에게 전달

- 긴 대화, 많은 기록을 모두 집어넣으면 토큰이 증가하고 답변 정확도가 떨어지고, 관련없는 정보 때문에 핵심을 놓침

- 방법: 조건 필터링, 태그 기반 메모리 조회, Vector Similarity 등

3. Compress : 핵심만

- 에이전트가 기억하고 있는 긴 기록이나 복잡한 출력 결과를 핵심 정보만 남겨 요약하거나 정제해서 LLM에게 전달하는 전략

- 긴 기록을 그대로 넣으면 토큰이 초과하거나 llm이 핵심을 못잡거나..

- llm 써서 요약하거나 rule-based 방식으로 요약 또는 추출

4. Isolate : 서로 다른 주제는 분리

- 하나의 사용자와 여러 주제를 동시에 다룰 때 정보가 섞이지 않도록 각 주제별로 따로 나누어 저장하고 사용할 때도 명확히 구분해서 불러오기

- llm 기반 에이전트는 모든 걸 연결하려는 경향이 있어 분리가 필요

- 메모리 구조를 주제별로 나누거나 아예 에이전트를 다르게 설계

LangChain, LangGraph

라구넹 — Mon, 8 Dec 2025 01:02:46 +0900

Ollama

- 사용자가 자신의 컴퓨터에 대규모 언어 모델을 쉽게 설치하고 실행할 수 있도록 돕는 도구

- 인터넷 연결 없이도 로컬 환경에서 AI 모델을 활용할 수 있게 해주며 복잡한 LLM 기능을 더 쉽게 사용할 수 있도록 감싸주는 래퍼 역할

- 허깅페이스에서 모델을 직접 다운로드하여 사용하는 것보다 훨씬 빠른 처리 속도 제공

Prompt Engineering

Prompt

- 사용자가 LLM에게 질의 시 제공하는 지침이나 입력의 집합

- 모델의 응답을 안내하고 문맥을 이해하며, 질문에 답하거나 문장을 완성하거나 대화를 나누는 등 관련성 있고 일관된 언어 기반 출력을 생성하는데 도움을 주는 역할

- 하지만 일반적으로 사용자들이 일반적인 질문을 하게 되면 원하는 결과가 나오지 않는 경우가 많음

- prompt engineering이 필요

Prompt engineering

- 목표: 사용자의 의도와 원하는 결과를 전달하는 프롬프트를 만들어 모델의 성능, 정확성, 유용성을 극대화

구성 요소

Instructions

- 모델에게 무엇을 해야 하는지, 제공된 경우 외부 정보를 어떻게 사용해야 하는지, 쿼리와 어떻게 처리해야 하는지, 출력물을 어떻게 구성해야 하는지

External Information or context(s)

- 모델에 대한 추가 지식의 원천. 프롬프트에 수동으로 삽입될 수 있고, 벡터 데이터베이스를 통해 검색된 정보일 수도 있고, 다른 수단을 통해 가져올 수도 있음

User input or query

- 사용자가 시스템에 입력한 쿼리

Output indicator

- 생성될 텍스트의 시작을 나타냄. (출력의 유형이나 형식을 지정)

효율적인 프롬프트의 예

역할(Role)

목표(Goal)

맥락(Context)

지시사항(Instructions)

제약사항(Constraints)

결과설정(Output)

- 형식

- 길이

- 톤 & 매너

Chain-of-Thought(CoT) Prompting

- 복잡한 작업에서 언어 모델의 성능을 향상시키기 위해 사용되는 기술

- 언어 모델이 답을 찾아가는 과정에서 생각을 말로 표현하거나(think aloud) 단계별 추론 과정(step-by-step reasoning)을 따르도록 유도하는 방식으로 구성

- 문제를 제기하는 것 뿐만 아니라 문제를 해결하기 위해 취할 수 있는 일련의 논리적 단계를 포함하여 프롬프트를 구성

Few-shot prompting

- 대규모 언어 모델에서 새로운 작업이 수행될 때, 몇 개의 예시를 제공하여 모델이 작업의 맥락과 요구 사항을 이해하도록 하는 기법

- 모델이 특정 작업을 배우기 위해 대량의 데이터나 사전 훈련 없이도 효과적으로 작동할 수 있게 도움을 줌

장점

빠른 학습 : 모델이 새로운 작업에 대해 빠르게 적응해야 할 때

적은 데이터 : 많은 예시를 제공할 수 없는 상황에서 유용

일관성 유지 : 모델이 특정 스타일이나 형식을 일관되게 유지해야 할 때

zero-shot prompting : 예시 제공 없이 질의

one ~ : 하나의 예시

Few ~ : 몇 개의 예시

LangChain

- 언어 모델을 활용하여 애플리케이션과 파이프라인을 신속하게 구축할 수 있는 플랫폼

LangChain 프레임워크의 구성

랭체인 라이브러리

- 파이썬과 자바스크립트 라이브러리를 포함

- 다양한 컴포넌트의 인터페이스와 통합, 이 컴포넌트들을 체인과 에이전트로 결합할 수 있는 기본 런타임, 그리고 체인과 에이전트

랭체인 템플릿

- 다양한 작업을 위한 쉽게 배포할 수 있는 참조 아키텍처 모음

- 개발자들이 특정 작업에 맞춰 빠르게 애플리케이션을 구축할 수 있도록 지원

랭서브

- 랭체인 체인을 REST API로 배포할 수 있게 하는 라이브러리

- 개발자들은 자신의 애플리케이션을 외부 시스템과 쉽게 통합 가능

랭스미스

- 개발자 플랫폼으로 LLM 프레임워크에서 구축된 체인을 디버깅, 테스트, 평가, 모니터링 가능

- 랭체인과의 원활한 통합을 지원

from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama import ChatOllama

template = """
	당신은 QA(Question-Answering)을 수행하는 Assistant입니다.
	{question}에 대해 설명하세요
	5문장 이내로 으로 답변하세요.
	"""

prompt = ChatPromptTemplate.from_template(template)

llm_model = ChatOllama(model="PetrosStav/gemma3-tools:4b")

rag_chain = prompt | llm_model

def answer_for(question):
	print("Answer :")
	for chunk in rag_chain.stream({"question": question}):
		print(chunk.content, end="", flush=True)
	
	print("\n")

랭체인 예시

template = """
	당신은 QA(Question-Answering)을 수행하는 Assistant입니다.
	{month}에 적합한 {event}를 추천해 주세요.
	5문장 이내로 으로 답변하세요.
	"""

이렇게 여러 변수를 전달도 가능

chat prompt

- ChatPromptTemplate은 대화형 상황에서 여러 메시지 입력을 기반으로 단일 메시지 응답을 생성하는데 사용

- 대화형 모델이나 챗봇 개발에 주로 사용

- 입력은 여러 메시지를 원소로 갖는 리스트로 구성, 각 메시지는 역할(role)과 내용(content)으로 구성

메시지의 유형

- SystemMessage : 시스템의 기능을 설명

- HumanMessage : 사용자의 질문

- AIMessage : AI 모델의 응답을 제공 (대화의 history를 기억시키는 역할)

- FunctionMessage : 특정 함수 호출의 결과

- ToolMessage : 도구 호출의 결과

대화의 유형

- 싱글턴(single-turn) : 바로 직전의 질문에만 대답

- 멀티턴(multi-turn) : 이전 대화를 계속 기억해 나가면서 대화를 이어나가는 것, 전체 대화의 맥락을 이해

* 멀티턴 구현 시 기본적인 답변 기능에 이전 대화 기록 저장 기능 추가 필요

from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama import ChatOllama

message = [
	("system", "너는 여행관련 전문가야."), # 역할 부여
	("system", "너는 한국어로 대화해."), # 작업지시
	("placeholder", "{chat_history}"), # 대화이력 저장
	("user", "{user_input}"), # 사용자 입력
]

chat_prompt = ChatPromptTemplate.from_messages(message)

placeholder : 원하는 위치에 동적으로 삽입될 메시지를 추가하기 위한 기능

- 여기선 이전 대화 히스토리를 저장하는데 사용

llm_model = ChatOllama(model="PetrosStav/gemma3-tools:4b")

rag_chain = chat_prompt | llm_model

chat_history = [
	("ai", "안녕하세요, 저는 여행 전문가 브라이언 입니다. 반갑습니다."),
	("user", "안녕, 나는 길동이야"),
	("user", "나는 여행을 좋아해. 너는 어떤 여행지를 추천해줄 수 있어?"),
	("ai", "세계 여러 나라의 여행지를 추천해 줄 수 있습니다. "),
]

def answer_for(user_input):
	chat_history.append(
		("human", user_input,)
	)
    
	whole_answer = ""
    
	for chunk in rag_chain.stream({"chat_history": chat_history, "user_input": user_input}):
		print(chunk.content, end="", flush=True)
		whole_answer += chunk.content
		chat_history.append(
			("ai", whole_answer,)
		)
        
		print("\n")

이런식으로 히스토리까지 연결 가능

LangGraph

- 기존 랭체인의 장점은 유지하면서도 더 복잡하고 상태(State)를 가진 다단계 추론 프로세스(Agentic Workflow)를 명확하게 정의하고 제어하기 위해 등장

- 랭체인이 LLM 애플리케이션 개발을 위한 도구 상자 역할을 했다면 LangGraph는 그 도구들을 조합하여 유한 상태 기계 형태의 복잡한 추론 흐름을 구현하는데 초점

랭체인의 한계와 해결책

복잡한 제어 흐름의 구현 어려움

-> 유연한 그래프 구조를 통해 조건부 분기, 루프, 순환 구조를 쉽게 정의

상태 관리의 불투명성

-> 중앙 집중식 상태 객체를 통해 워크플로우 전체의 상태 변화를 명확하게 추적하고 관리

순환 추론의 비효율성

-> 에이전트가 도구를 호출하고 결과를 관찰한 후 다시 행동을 결정하는 복잡한 루프 구조를 기본 요소로 지원하여 효율성을 높임

시각화 및 디버깅의 어려움

-> 그래프 구조 덕분에 워크플로우의 흐름을 시각적으로 파악하고 디버깅하기 쉬워짐

랭그래프 등장 배경

- 결국 워크플로우 간 상태관리를 하며 플로우를 더 쉽게 작성할 수 있도록 하는 프레임워크

- 랭체인 에이전트는 Production 용도에는 적합하지 않다는 권고, 랭그래프 사용을 권장함

비고	LangChain	LangGraph
prompt	Reasoning 과정 직접 작성	단순한 Agent 역할 부여
ReAct의 구현	프롬프트로 정의 + 랭체인 내부 구현	LangGraph로 구현
Function Call	프롬프트를 이용해서 LLM이 툴을 사용하게 유도	LLM 학습 당시 구현한 Tool Call API 사용
Tool 사용 가능 모델	모든 모델	Tool Call이 가능한 모델

Tool Calling (도구 호출)

- 자체적으로 수행할 수 없는 작업을 식별

- 필요한 데이터를 얻거나 작업을 수행하기 위해 외부 도구에 작업을 위임

- 도구에서 얻은 결과를 활용하여 사용자에게 응답을 생성

도구 호출을 사용하는 이유

- LLM은 실시간 정보에 접근 불가

- 외부 도움 없이는 특수 작업을 수행할 수 없음

- 도구 호출을 통해 다른 시스템과 협업하여 한계 극복

도구 호출 처리 과정

1. 사용자 입력 : 사용자가 AI가 직접 답을 알지 못하거나 외부 데이터가 필요할 수 있는 질문 제공

2. 도구 식별 : 모델은 질문에 답하기 위해 도구를 사용해야 함을 감지

3. 도구 요청 : 모델은 도구에 대한 요청을 형식화

4. 도구 실행 : 도구는 요청을 처리하고 결과를 반환

5. 응답 구성 : AI는 도구의 응답을 사용자 친화적인 답변으로 통합

LangGraph 정의 단계

- State 정의

- 노드 정의

- 그래프 정의

- 그래프 컴파일

- 그래프 시각화

Hugging face

라구넹 — Sun, 7 Dec 2025 23:42:42 +0900

Hugging face

기계학습 모델을 구축, 배포 및 교육하기 위한 도구와 리소스를 개발하는 프랑스계 미국 회사이자 오픈 소스 커뮤니티

트랜스포머나 데이터셋 같은 AI 프레임워크를 제공하는 세계 최대의 인공지능 플랫폼 중 하나

다양한 오픈소스 LLM 모델들과 라이브러리를 제공

모델명

meta-llama/Llama-3.1-8B-Instruct

meta-llama : 모델 개발업체 / 개발자

Llama-3.1-8B-Instruct : 모델명(checkpoint)

3.1 : 버전

8B : 매개변수의 수

Instruct

- 있는 것 : 사용자 명령에 반응하는 특화된 훈련을 통해 명령에 더 정확하게 답하거나 특정 작업을 수행하는데 최적화

- 없는 것 : 일반적인 언어 패턴을 학습하여 모든 종류의 텍스트 생성에 적합한 범용 모델

* 일반 노트북이나 데탑은 4B 이하 모델이 현실적

Instruction Tuning

- 모델이 사용자 지시나 명령에 더 잘 반응하도록 훈련하는 과정

- 모델이 명령어와 그에 따른 응답 쌍으로 이루어진 데이터셋을 학습

Context In LLM

- 모델이 답변을 생성할 때 고려하는 정보

구성요소

- 인풋 텍스트(프롬프트)

- 대화 기록

- 유저 프로필

- 학습된 데이터

- 외부 데이터(RAG)

Context(window) Length

- 모델이 텍스트를 생성하거나 이해할 때 받을 수 있는 입력 정보의 양

- 입력 토큰의 수로 측정

- 이 값이 클 수록 유리하나 계산이 지수적으로 증가

LLM 모델의 저장 방식

Safetensor

- 딥러닝 모델의 가중치를 저장하기 위해 설계된 새로운 바이너리 파일 포맷

- 높은 보안성, 빠른 로딩 속도, 메모리 효율성, 프레임워크 독립성 제공

- 구성 요소: JSON 헤더, 바이너리 데이터 블록

GGUF (GPT-Generated Unified Format)

- llama.cpp 프로젝트에서 개발된 포맷

- llm을 효율적으로 저장하고 CPU 및 GPU에서 실행할 수 있도록 최적화

- safetensors와 마찬가지로 pickle 기반의 보안 취약점을 해결하고 모델 로딩 속도 및 효율성을 개선하는데 중점

- Ollama의 모델들은 이 포맷

ONNX (Open Neural Network)

- Meta, Microsoft 주도 개발

- 딥러닝 모델을 표현하기 위한 개방향 표준 포맷

- 다양한 딥러닝 프레임워크에서 학습된 모델을 ONNX 형식으로 변환하여 다른 프레임워크나 런타임에서 추론할 수 있도록 함

- 프레임워크 독립적이며 추론 성능 최적화에 유리

제공 라이브러리

Transformer

- 허깅페이스 라이브러리 중 가장 핵심적 모듈

- 트랜스포머 기반의 다양한 모델을 파이토치, 텐서플로우로 각각 구현해놓은 모듈이며 각 모델에 맞는 tokenizer도 구현

- 사전 학습된 최첨단 모델들을 쉽게 다운로드하고 훈련시킬 수 있는 API와 도구 제공

- Pipeline을 통한 고수준 추상화 제공

지원 작업

- NLP : 텍스트 분류, 텍스트 생성, 개체명 인식, 질의응답, 빈칸 채우기, 요약, 번역

- CV : 이미지 분류, 이미지 분할, 객체 탐지

- 오디오 : 오디오 분류, 자동 음성 인식

- 멀티모달 : 시각 질의응답, 문서 질의응답, 이미지 캡션 달기

Tokenizer

- 텍스트 데이터를 컴퓨터가 처리할 수 있도록 토큰화 작업을 지원

- 토큰화 뿐만 아니라 텍스트 정규화, 불용어 제거, 패딩 등 다양한 전처리 수행

- 토큰화 후 숫자 인코딩 수헹

datasets

- 자연어처리, 컴퓨터 비전, 오디오 처리 등 다양한 머신러닝 작업에 사용되는 수많은 데이터셋을 쉽게 다룰 수 있도록 도와주는 라이브러리

diffuser

- 딥러닝 기반의 생성형 AI 모델, 특히 텍스트-이미지 생성과 관련된 작업을 지원

accelerate

- 딥러닝 모델의 분산 학습과 하드웨어 가속화를 지원

- 대규모 모델을 효과적으로 학습하기 위해서는 여러 GPU를 사용한 병렬처리가 필수적인데 매우 복잡한 과정이 필요

- 이러한 작업을 추상화를 통해 간단한 API로 제공

Pipeline

- transformers 라이브러리의 가장 기본 객체

- 모델 사용을 위한 인터페이스 제공

- 전처리 + 후처리 과정을 모델과 연결하여 쉽게 NLP 모델을 사용할 수 있게 함

- Transformer를 사용하는 가장 간단한 수단

Pipeline으로 가능한 작업

- sentiment-analysis : 감정 분석

- question-answering : 질의 응답

- text-generation : 텍스트 생성

- translation : 번역

- summarzation : 요약

- image-classification : 이미지 분류

- object-detection : 객체 탐지

- image-to-text : 이미지에 캡션 달기

- feature-extraction : 특징 추출

- fill-mask : 마스크 채우기

- ner : 개체명 인식

- zero-shot-classification : 제로샷 분류

* Type of ansert

- 추출적(Extractive) 질의 응답 : 주어진 문맥에서 답변을 추출

- 생성적(Abstractive) 질의 응답 : 문맥에서 질문에 올바르게 답하는 답변을 생성