자세한 지침은 [설치 가이드](https://docs.nvidia.com/nemo/guardrails/get-started/installation-guide)를 참조하세요.

## 개요

<!-- start-documentation-reuse -->

NeMo Guardrails 라이브러리를 사용하면 LLM 기반 애플리케이션을 개발하는 개발자가 애플리케이션 코드와 LLM 사이에 **프로그래밍 가능한 가드레일**을 추가할 수 있습니다.

<div align="center">
  <img src="https://raw.githubusercontent.com/NVIDIA-NeMo/Guardrails/develop/docs/_static/images/programmable_guardrails.png"  width="75%" alt="Programmable Guardrails">
</div>

*프로그래밍 가능한 가드레일*을 추가할 때 얻을 수 있는 주요 이점은 다음과 같습니다:

- **신뢰할 수 있고 안전하며 보안이 강화된 LLM 기반 애플리케이션 구축:** 대화를 안내하고 보호하기 위한 레일을 정의할 수 있으며, 특정 주제에 대한 LLM 기반 애플리케이션의 동작을 정의하고 원치 않는 주제에 대한 논의에 참여하지 않도록 방지할 수 있습니다.

- **모델, 체인 및 기타 서비스를 안전하게 연결:** LLM을 다른 서비스(일명 도구)에 원활하고 안전하게 연결할 수 있습니다.

- **제어 가능한 대화**: 미리 정의된 대화 경로를 따르도록 LLM을 조종할 수 있어, 대화 설계 모범 사례에 따라 상호작용을 설계하고 표준 운영 절차(예: 인증, 지원)를 시행할 수 있습니다.

<!-- end-documentation-reuse -->

### LLM 취약점으로부터 보호

NeMo Guardrails 라이브러리는 탈옥(jailbreak) 및 프롬프트 인젝션과 같은 일반적인 LLM 취약점으로부터 LLM 기반 채팅 애플리케이션을 보호하기 위한 여러 메커니즘을 제공합니다. 아래는 이 저장소에 포함된 예제 [ABC Bot](https://github.com/nvidia-nemo/guardrails/blob/develop/examples/bots/abc)에 대해 다양한 가드레일 구성이 제공하는 보호 기능에 대한 샘플 개요입니다. 자세한 내용은 [LLM 취약점 스캐닝](https://docs.nvidia.com/nemo/guardrails/evaluation/llm-vulnerability-scanning.html) 페이지를 참조하세요.

<div align="center">
<img src="https://raw.githubusercontent.com/NVIDIA-NeMo/Guardrails/develop/docs/_static/images/abc-llm-vulnerability-scan-results.png" width="500">
</div>

### 사용 사례

프로그래밍 가능한 가드레일은 다양한 유형의 사용 사례에서 사용할 수 있습니다:

1. 문서 집합에 대한 **질의응답**(일명 검색 증강 생성): 사실 확인 및 출력 조정을 시행합니다.
2. **도메인 특화 어시스턴트**(일명 챗봇): 어시스턴트가 주제를 벗어나지 않고 설계된 대화 흐름을 따르도록 보장합니다.
3. **LLM 엔드포인트**: 더 안전한 고객 상호작용을 위해 사용자 정의 LLM에 가드레일을 추가합니다.
4. **LangChain 체인**(선택 사항): 어떤 사용 사례에서든 LangChain을 사용하는 경우, 체인 주위에 가드레일 계층을 추가할 수 있습니다. 이 통합을 활성화하려면 `NEMOGUARDRAILS_LLM_FRAMEWORK=langchain` 환경 변수를 설정하거나 `set_default_framework("langchain")`을 호출하세요.

### 사용법

애플리케이션에 프로그래밍 가능한 가드레일을 추가하려면 Python API 또는 가드레일 서버를 사용할 수 있습니다(자세한 내용은 [서버 가이드](https://docs.nvidia.com/nemo/guardrails/get-started/integrate-into-application) 참조). Python API 사용은 LLM을 직접 사용하는 것과 유사합니다. LLM 대신 가드레일 계층을 호출하려면 코드베이스를 최소한으로만 변경하면 되며, 다음 두 가지 간단한 단계로 이루어집니다:

1. 가드레일 구성을 로드하고 `LLMRails` 인스턴스를 생성합니다.
2. `generate`/`generate_async` 메서드를 사용하여 LLM을 호출합니다.```python
from nemoguardrails import LLMRails, RailsConfig

# Load a guardrails configuration from the specified path.
config = RailsConfig.from_path("PATH/TO/CONFIG")
rails = LLMRails(config)

completion = rails.generate(
    messages=[{"role": "user", "content": "Hello world!"}]
)

`generate` 메서드의 입력 및 출력 형식은 OpenAI의 [Chat Completions API](https://platform.openai.com/docs/guides/gpt/chat-completions-api)와 유사합니다.

#### 비동기 API

NeMo Guardrails 라이브러리는 핵심 메커니즘이 Python 비동기 모델을 사용하여 구현된 비동기 우선 툴킷입니다. 공개 메서드는 동기 버전과 비동기 버전을 모두 제공합니다. 예를 들어 `LLMRails.generate`와 `LLMRails.generate_async`가 있습니다.

### 지원되는 LLM

NeMo Guardrails는 OpenAI GPT-3.5, GPT-4, LLaMa-2, Falcon, Vicuna, Mosaic 등 여러 LLM과 함께 사용할 수 있습니다. 자세한 내용은 구성 가이드의 [지원되는 LLM 모델](https://docs.nvidia.com/nemo/guardrails/about-nemo-guardrails-library/supported-llms) 섹션을 참고하세요.

### 가드레일의 유형

NeMo Guardrails 라이브러리는 다섯 가지 주요 가드레일 유형을 지원합니다:

<div align="center">
  <img src="https://raw.githubusercontent.com/NVIDIA-NeMo/Guardrails/develop/docs/_static/images/programmable_guardrails_flow.png"  width="75%" alt="Programmable Guardrails Flow">
</div>

1. **입력 레일**: 사용자의 입력에 적용됩니다. 입력 레일은 입력을 거부하여 추가 처리를 중단하거나, 입력을 변경할 수 있습니다(예: 잠재적으로 민감한 데이터를 마스킹하거나 표현을 바꾸는 경우).

2. **대화 레일**: LLM이 어떻게 프롬프트되는지에 영향을 줍니다. 대화 레일은 정규 형식 메시지에 대해 동작하며(자세한 내용은 [Colang 가이드](https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang) 참고), 액션을 실행해야 하는지, 다음 단계나 응답을 생성하기 위해 LLM을 호출해야 하는지, 미리 정의된 응답을 대신 사용해야 하는지 등을 결정합니다.

3. **검색 레일**: RAG(검색 증강 생성) 시나리오에서 검색된 청크에 적용됩니다. 검색 레일은 청크를 거부하여 LLM 프롬프트에 사용되지 않도록 하거나, 관련 청크를 변경할 수 있습니다(예: 잠재적으로 민감한 데이터를 마스킹하는 경우).

4. **실행 레일**: LLM이 호출해야 하는 사용자 정의 액션(일명 도구)의 입력/출력에 적용됩니다.

5. **출력 레일**: LLM이 생성한 출력에 적용됩니다. 출력 레일은 출력을 거부하여 사용자에게 반환되지 않도록 하거나, 출력을 변경할 수 있습니다(예: 민감한 데이터 제거).

### 가드레일 구성

가드레일 구성은 사용할 **LLM**과 **하나 이상의 가드레일**을 정의합니다. 가드레일 구성에는 원하는 수의 입력/대화/출력/검색/실행 레일을 포함할 수 있습니다. 구성된 레일이 없는 구성은 기본적으로 요청을 LLM으로 전달합니다.

가드레일 구성 폴더의 표준 구조는 다음과 같습니다:```
.
├── config
│   ├── actions.py
│   ├── config.py
│   ├── config.yml
│   ├── rails.co
│   ├── ...

guardrails 구성에 포함된 `.co` 파일에는 다양한 유형의 레일을 정의하는 Colang 정의(Colang이 무엇인지에 대한 간략한 개요는 다음 섹션 참조)가 들어 있습니다. 아래는 사용자에게 인사하는 대화 레일을 정의하는 `greeting.co` 파일의 예시입니다.```colang
define user express greeting
  "Hello!"
  "Good afternoon!"

define flow
  user express greeting
  bot express greeting
  bot offer to help

define bot express greeting
  "Hello there!"

define bot offer to help
  "How can I help you today?"

### Colang

다양한 유형의 가드레일을 구성하고 구현하기 위해, 이 툴킷은 유연하면서도 제어 가능한 대화 흐름을 설계하기 위해 특별히 만들어진 모델링 언어인 **Colang**을 도입합니다. Colang은 파이썬과 유사한 구문을 가지고 있으며, 특히 개발자에게 간단하고 직관적으로 설계되었습니다.```{note}
Two versions of Colang, 1.0 and 2.0, are supported and Colang 1.0 is the default.

이 라이브러리는 LLM 자체 점검(입력/출력 검열, 사실 확인, 환각 탐지), NVIDIA 안전 모델(콘텐츠 안전, 주제 안전), 탈옥 및 인젝션 탐지, 그리고 커뮤니티 모델 및 서드파티 API와의 통합을 위한 가드레일을 포함합니다. 전체 목록은 [Guardrails Library 문서](https://docs.nvidia.com/nemo/guardrails/user-guides/guardrails-library.html)를 참조하세요.

## CLI

NeMo Guardrails 라이브러리에는 내장 CLI도 함께 제공됩니다.```bash
$ nemoguardrails --help

Usage: nemoguardrails [OPTIONS] COMMAND [ARGS]...

actions-server    Start a NeMo Guardrails actions server.
chat              Start an interactive chat session.
evaluate          Run an evaluation task.
server            Start a NeMo Guardrails server.

예를 들어, `sample` 구성에 대한 채팅 완성을 얻으려면 `/v1/chat/completions` 엔드포인트를 사용할 수 있습니다:```
POST /v1/chat/completions

def get_network_connections(self):
    """
    네트워크 연결에 대한 정보를 검색합니다.

    Returns:
        list: 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.status == psutil.CONN_ESTABLISHED:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"네트워크 연결 검색 오류: {e}")
        return []

def get_network_interfaces(self):
    """
    네트워크 인터페이스에 대한 정보를 검색합니다.

    Returns:
        dict: 인터페이스 이름을 키로 하고 해당 세부 정보를 값으로 하는 딕셔너리입니다.
    """
    try:
        interfaces = {}
        for interface, addrs in psutil.net_if_addrs().items():
            interfaces[interface] = []
            for addr in addrs:
                interfaces[interface].append({
                    'family': str(addr.family),
                    'address': addr.address,
                    'netmask': addr.netmask,
                    'broadcast': addr.broadcast
                })
        return interfaces
    except Exception as e:
        logger.error(f"네트워크 인터페이스 검색 오류: {e}")
        return {}

def get_network_stats(self):
    """
    네트워크 통계에 대한 정보를 검색합니다.

    Returns:
        dict: 인터페이스 이름을 키로 하고 해당 통계를 값으로 하는 딕셔너리입니다.
    """
    try:
        stats = {}
        for interface, stat in psutil.net_if_stats().items():
            stats[interface] = {
                'isup': stat.isup,
                'duplex': stat.duplex,
                'speed': stat.speed,
                'mtu': stat.mtu
            }
        return stats
    except Exception as e:
        logger.error(f"네트워크 통계 검색 오류: {e}")
        return {}

def get_network_io_counters(self):
    """
    네트워크 I/O 카운터에 대한 정보를 검색합니다.

    Returns:
        dict: 인터페이스 이름을 키로 하고 해당 I/O 카운터를 값으로 하는 딕셔너리입니다.
    """
    try:
        io_counters = {}
        for interface, counters in psutil.net_io_counters(pernic=True).items():
            io_counters[interface] = {
                'bytes_sent': counters.bytes_sent,
                'bytes_recv': counters.bytes_recv,
                'packets_sent': counters.packets_sent,
                'packets_recv': counters.packets_recv,
                'errin': counters.errin,
                'errout': counters.errout,
                'dropin': counters.dropin,
                'dropout': counters.dropout
            }
        return io_counters
    except Exception as e:
        logger.error(f"네트워크 I/O 카운터 검색 오류: {e}")
        return {}

def get_network_connections_by_process(self, pid):
    """
    특정 프로세스의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        pid (int): 프로세스 ID입니다.

    Returns:
        list: 지정된 프로세스의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.Process(pid).connections(kind='inet'):
            if conn.status == psutil.CONN_ESTABLISHED:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status
                })
        return connections
    except Exception as e:
        logger.error(f"프로세스 {pid}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_address(self, address):
    """
    특정 주소의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        address (str): 검색할 주소입니다.

    Returns:
        list: 지정된 주소의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.status == psutil.CONN_ESTABLISHED and (conn.laddr.ip == address or conn.raddr.ip == address):
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"주소 {address}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_port(self, port):
    """
    특정 포트의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        port (int): 검색할 포트입니다.

    Returns:
        list: 지정된 포트의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.status == psutil.CONN_ESTABLISHED and (conn.laddr.port == port or conn.raddr.port == port):
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"포트 {port}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_status(self, status):
    """
    특정 상태의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        status (str): 검색할 상태입니다.

    Returns:
        list: 지정된 상태의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.status == status:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"상태 {status}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_family(self, family):
    """
    특정 주소 패밀리의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        family (str): 검색할 주소 패밀리입니다.

    Returns:
        list: 지정된 주소 패밀리의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if str(conn.family) == family:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"주소 패밀리 {family}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_type(self, type):
    """
    특정 유형의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        type (str): 검색할 유형입니다.

    Returns:
        list: 지정된 유형의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if str(conn.type) == type:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"유형 {type}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_fd(self, fd):
    """
    특정 파일 디스크립터의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        fd (int): 검색할 파일 디스크립터입니다.

    Returns:
        list: 지정된 파일 디스크립터의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.fd == fd:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"파일 디스크립터 {fd}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_pid(self, pid):
    """
    특정 프로세스 ID의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        pid (int): 검색할 프로세스 ID입니다.

    Returns:
        list: 지정된 프로세스 ID의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.pid == pid:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"프로세스 ID {pid}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_local_address(self, local_address):
    """
    특정 로컬 주소의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        local_address (str): 검색할 로컬 주소입니다.

    Returns:
        list: 지정된 로컬 주소의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.laddr.ip == local_address:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"로컬 주소 {local_address}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_remote_address(self, remote_address):
    """
    특정 원격 주소의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        remote_address (str): 검색할 원격 주소입니다.

    Returns:
        list: 지정된 원격 주소의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.raddr and conn.raddr.ip == remote_address:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"원격 주소 {remote_address}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_local_port(self, local_port):
    """
    특정 로컬 포트의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        local_port (int): 검색할 로컬 포트입니다.

    Returns:
        list: 지정된 로컬 포트의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.laddr.port == local_port:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"로컬 포트 {local_port}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_remote_port(self, remote_port):
    """
    특정 원격 포트의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        remote_port (int): 검색할 원격 포트입니다.

    Returns:
        list: 지정된 원격 포트의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.raddr and conn.raddr.port == remote_port:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"원격 포트 {remote_port}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_local_address_and_port(self, local_address, local_port):
    """
    특정 로컬 주소와 포트의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        local_address (str): 검색할 로컬 주소입니다.
        local_port (int): 검색할 로컬 포트입니다.

    Returns:
        list: 지정된 로컬 주소와 포트의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.laddr.ip == local_address and conn.laddr.port == local_port:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"로컬 주소 {local_address} 및 포트 {local_port}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_remote_address_and_port(self, remote_address, remote_port):
    """
    특정 원격 주소와 포트의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        remote_address (str): 검색할 원격 주소입니다.
        remote_port (int): 검색할 원격 포트입니다.

    Returns:
        list: 지정된 원격 주소와 포트의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.raddr and conn.raddr.ip == remote_address and conn.raddr.port == remote_port:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"원격 주소 {remote_address} 및 포트 {remote_port}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_local_and_remote_address(self, local_address, remote_address):
    """
    특정 로컬 및 원격 주소의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        local_address (str): 검색할 로컬 주소입니다.
        remote_address (str): 검색할 원격 주소입니다.

    Returns:
        list: 지정된 로컬 및 원격 주소의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.laddr.ip == local_address and conn.raddr and conn.raddr.ip == remote_address:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"로컬 주소 {local_address} 및 원격 주소 {remote_address}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_local_and_remote_port(self, local_port, remote_port):
    """
    특정 로컬 및 원격 포트의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        local_port (int): 검색할 로컬 포트입니다.
        remote_port (int): 검색할 원격 포트입니다.

    Returns:
        list: 지정된 로컬 및 원격 포트의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.laddr.port == local_port and conn.raddr and conn.raddr.port == remote_port:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"로컬 포트 {local_port} 및 원격 포트 {remote_port}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_local_address_and_remote_port(self, local_address, remote_port):
    """
    특정 로컬 주소와 원격 포트의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        local_address (str): 검색할 로컬 주소입니다.
        remote_port (int): 검색할 원격 포트입니다.

    Returns:
        list: 지정된 로컬 주소와 원격 포트의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.laddr.ip == local_address and conn.raddr and conn.raddr.port == remote_port:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"로컬 주소 {local_address} 및 원격 포트 {remote_port}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_local_port_and_remote_address(self, local_port, remote_address):
    """
    특정 로컬 포트와 원격 주소의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        local_port (int): 검색할 로컬 포트입니다.
        remote_address (str): 검색할 원격 주소입니다.

    Returns:
        list: 지정된 로컬 포트와 원격 주소의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.laddr.port == local_port and conn.raddr and conn.raddr.ip == remote_address:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"로컬 포트 {local_port} 및 원격 주소 {remote_address}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_local_address_and_remote_address(self, local_address, remote_address):
    """
    특정 로컬 및 원격 주소의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        local_address (str): 검색할 로컬 주소입니다.
        remote_address (str): 검색할 원격 주소입니다.

    Returns:
        list: 지정된 로컬 및 원격 주소의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.laddr.ip == local_address and conn.raddr and conn.raddr.ip == remote_address:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"로컬 주소 {local_address} 및 원격 주소 {remote_address}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_local_port_and_remote_port(self, local_port, remote_port):
    """
    특정 로컬 및 원격 포트의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        local_port (int): 검색할 로컬 포트입니다.
        remote_port (int): 검색할 원격 포트입니다.

    Returns:
        list: 지정된 로컬 및 원격 포트의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.laddr.port == local_port and conn.raddr and conn.raddr.port == remote_port:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"로컬 포트 {local_port} 및 원격 포트 {remote_port}의 네트워크 연결 검색 오류: {e}")
        return []

def get_network_connections_by_local_address_and_remote_address_and_port(self, local_address, remote_address, remote_port):
    """
    특정 로컬 주소, 원격 주소 및 포트의 네트워크 연결에 대한 정보를 검색합니다.

    Args:
        local_address (str): 검색할 로컬 주소입니다.
        remote_address (str): 검색할 원격 주소입니다.
        remote_port (int): 검색할 원격 포트입니다.

    Returns:
        list: 지정된 로컬 주소, 원격 주소 및 포트의 네트워크 연결 정보를 담은 딕셔너리 목록입니다.
    """
    try:
        connections = []
        for conn in psutil.net_connections(kind='inet'):
            if conn.laddr.ip == local_address and conn.raddr and conn.raddr.ip == remote_address and conn.raddr.port == remote_port:
                connections.append({
                    'fd': conn.fd,
                    'family': str(conn.family),
                    'type': str(conn.type),
                    'laddr': f"{conn.laddr.ip}:{conn.laddr.port}",
                    'raddr': f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else None,
                    'status': conn.status,
                    'pid': conn.pid
                })
        return connections
    except Exception as e:
        logger.error(f"```json
{
    "config_id": "sample",
    "messages": [{
      "role":"user",
      "content":"Hello! What can you do for me?"
    }]
}

#### Docker

가드레일 서버를 시작하려면 Docker 컨테이너를 사용할 수도 있습니다. NeMo Guardrails 라이브러리는 `nemoguardrails` 이미지를 빌드하는 데 사용할 수 있는 [Dockerfile](https://github.com/nvidia-nemo/guardrails/blob/develop/Dockerfile)을 제공합니다. 자세한 내용은 [Docker 사용](https://docs.nvidia.com/nemo/guardrails/user-guides/advanced/using-docker.html) 섹션을 참조하세요.

## LangChain과의 통합 (선택 사항)

LangChain 통합은 옵트인 방식입니다. 이를 활성화하려면 `NEMOGUARDRAILS_LLM_FRAMEWORK=langchain` 환경 변수를 설정하거나 `set_default_framework("langchain")`을 호출하세요. 그런 다음 구성에 필요한 LangChain 패키지를 설치하세요. 통합을 활성화한 후에는 LangChain 체인(또는 모든 `Runnable`)을 가드레일 구성으로 감쌀 수 있으며, 가드레일 구성 내에서 LangChain 체인을 호출할 수 있습니다. 자세한 내용은 [LangChain 통합 문서](https://docs.nvidia.com/nemo/guardrails/user-guides/langchain/langchain-integration.html)를 참조하세요.

## 평가

LLM 기반 대화형 애플리케이션의 안전성을 평가하는 것은 복잡한 작업이며 여전히 미해결 연구 과제입니다. 적절한 평가를 지원하기 위해 NeMo Guardrails 라이브러리는 다음을 제공합니다:

1. 주제별 레일, 팩트 체킹, 검열(탈옥 및 출력 검열) 및 환각을 지원하는 [평가 도구](https://github.com/nvidia-nemo/guardrails/blob/develop/nemoguardrails/evaluate/README.md), 즉 `nemoguardrails evaluate`.
2. 샘플 LLM 취약점 스캔 보고서, 예: [ABC Bot - LLM 취약점 스캔 결과](https://docs.nvidia.com/nemo/guardrails/evaluation/llm-vulnerability-scanning.html)

## 이것은 무엇이 다른가요?

LLM 기반 대화형 애플리케이션에 가드레일을 추가하는 방법은 다양합니다. 예를 들어: 명시적 검열 엔드포인트(예: OpenAI, ActiveFence, PolicyAI), 비평 체인(예: constitutional chain), 출력 파싱(예: guardrails.ai), 개별 가드레일(예: LLM-Guard), RAG 애플리케이션을 위한 환각 감지(예: Got It AI, Patronus Lynx) 등이 있습니다.

NeMo Guardrails 라이브러리는 이러한 모든 상호 보완적 접근 방식을 일관된 LLM 가드레일 계층으로 통합할 수 있는 유연한 툴킷을 제공하는 것을 목표로 합니다. 예를 들어, 이 툴킷은 ActiveFence, PolicyAI, AlignScore 및 LangChain 체인과의 즉시 사용 가능한 통합을 제공합니다.

우리가 아는 한, NeMo Guardrails 라이브러리는 사용자와 LLM 간의 대화를 모델링하는 솔루션을 제공하는 유일한 가드레일 툴킷입니다. 이는 한편으로는 대화를 정밀한 방식으로 안내할 수 있는 능력을 가능하게 합니다. 다른 한편으로는 특정 가드레일이 언제 사용되어야 하는지에 대한 세밀한 제어를 가능하게 합니다. 예를 들어, 특정 유형의 질문에만 팩트 체킹을 사용하는 것입니다.

## 더 알아보기

- [문서](https://docs.nvidia.com/nemo/guardrails)
- [시작 가이드](https://docs.nvidia.com/nemo/guardrails/getting-started)
- [예제](https://github.com/nvidia-nemo/guardrails/blob/develop/examples)
- [FAQ](https://docs.nvidia.com/nemo/guardrails/faqs.html)
- [보안 가이드라인](https://docs.nvidia.com/nemo/guardrails/security/guidelines.html)

## 텔레메트리 및 개인정보 보호

NVIDIA NeMo Guardrails 라이브러리는 NVIDIA가 어떤 배포 패턴과 안전 기능이 가장 많이 사용되는지 이해하는 데 도움이 되도록 익명 텔레메트리를 수집합니다. 이 라이브러리는 `LLMRails`, `IORails` 또는 `Guardrails`를 인스턴스화할 때 하나의 사용 이벤트를 내보낸 다음, 프로세스당 단일 데몬 스레드에서 주기적인 하트비트를 내보냅니다. 이 텔레메트리는 요청별 [추적](https://docs.nvidia.com/nemo/guardrails/latest/observability/tracing/index.html)과는 별개입니다. 추적은 가드레일 구성에서 구성하고 자체 관찰 가능성 백엔드로 전송합니다. 텔레메트리는 NVIDIA에 대한 최소한의 익명 핑입니다.

### 커뮤니티 사용량 스냅샷

정확한 `0.22.0` 및 `0.23.0` 릴리스 빌드에 걸친 집계된 익명 사용량, 2026년 5월 22일–8월 18일:

![레일 유형별 세션](https://assets.kitploit.com/production/public/readmes/51007/5c817f183980e89808ce8be263ceebbfa7d9deed6b646fb16ce020f203e38923/493c6d2c9a0d81af5bbd7ebfaf0cdbb06d21c64d4786f8b7082150eb9e42fd40-display-v1.webp)

![내장 기능별 세션](https://assets.kitploit.com/production/public/readmes/51007/89ba78eebea3784baeb13513865883714c3daf62a440742478efd4689a27698b/73327d185c0ca512c4a3b837e70dd54bc243ce873a6e4051aff3e0c9a314311e-display-v1.webp)

![시작 시 구성된 레일](https://assets.kitploit.com/production/public/readmes/51007/94f316ceecd9de13b14b9b38766a36884f82175a9cf4b08dcdeeb9544ae1668c/29fd7090a76d6ee66edef8f64cfdc84ec7c5a446c4b89d65aaafdc2f1db3c74e-display-v1.webp)

_최종 업데이트: 2026년 8월 18일_

텔레메트리에는 다음이 포함됩니다:

- 설치된 라이브러리 버전, Python 버전, 운영 체제 및 플랫폼 문자열
- Colang 구성 언어 버전 (1.0 또는 2.x)
- 구성된 LLM 엔진 제공자 이름, 예: `openai`, `nim` 또는 `nvidia_ai_endpoints`, 모델 이름이나 자격 증명은 절대 포함되지 않음
- 입력, 출력, 검색, 도구 입력 및 도구 출력 레일에 대해 구성된 레일 흐름 수, 그리고 어떤 레일 카테고리가 활성화되어 있는지
- 활성화된 내장 라이브러리 기능 이름, 예: `jailbreak_detection`, `content_safety` 또는 `topic_safety`
- 사용자 정의 Colang 흐름 수 (수만 집계, 흐름 이름이나 내용은 절대 포함되지 않음)
- 추적, 스트리밍 또는 지식 기반이 구성되어 있는지 여부
- 가드레일을 어떻게 배포했는지 (`library`, `api` 또는 `cli` 서버)
- 어떤 런타임 레일 엔진이 사용 중인지 (`LLMRails` 또는 `IORails`)
- 동일한 인스턴스의 이벤트를 연관시키기 위한 프로세스별 무작위 UUID. 라이브러리는 이를 메모리에서 생성하고 재시작 간 재사용을 위해 저장하지 않지만, 감사 기록 및 전송된 텔레메트리 이벤트에 포함합니다

이벤트 페이로드에는 사용자 콘텐츠가 수집되지 않습니다. 페이로드에는 모델 이름, API 키, 엔드포인트, 프롬프트, 완성, 토큰 수, 요청별 메트릭, 파일 경로, 사용자 이름 또는 IP 주소가 포함되지 않습니다. NVIDIA는 집계된 데이터를 엔지니어링 작업의 우선순위를 정하는 데 사용하며, 채택 추세를 커뮤니티와 공유할 것입니다.

또한 라이브러리는 각 이벤트 페이로드를 `~/.config/nemoguardrails/usage_stats.json`의 로컬 감사 파일에 기록하려고 시도합니다. 감사 파일은 전체 NVIDIA 텔레메트리 봉투가 아닌 이벤트 JSONL을 저장합니다. 감사 쓰기는 최선의 노력으로 수행되며, 로컬 감사 쓰기가 실패하더라도 텔레메트리 전송은 계속 진행됩니다.

텔레메트리를 비활성화하려면 다음 옵션 중 하나를 설정하세요:```bash
export NEMO_GUARDRAILS_NO_USAGE_STATS=1
# or
export DO_NOT_TRACK=1
# or
mkdir -p ~/.config/nemoguardrails && touch ~/.config/nemoguardrails/do_not_track