> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getpatter.com/llms.txt
> Use this file to discover all available pages before exploring further.

# DeepFilterNet

> Open-source DeepFilterNet3 noise suppression as a Patter AudioFilter.

# DeepFilterNet Filter

`DeepFilterNetFilter` is a Patter `AudioFilter` backed by the [DeepFilterNet3](https://github.com/Rikorose/DeepFilterNet) deep-learning noise suppressor. Like [Krisp](/python-sdk/providers/krisp-filter), it runs as a pre-STT filter in pipeline mode: caller PCM enters the filter, cleaned PCM exits and is forwarded to the STT provider.

DeepFilterNet is **MIT-licensed and free**. Use it as the default OSS noise-suppression option, or where Krisp's commercial licence isn't a fit.

## Install

DeepFilterNet works natively at 48 kHz; the filter resamples around inference automatically. Heavy deps (`torch` \~2 GB, model \~60 MB) are opt-in:

<CodeGroup>
  ```bash Python theme={null}
  pip install "getpatter[deepfilternet]"   # installs deep-filter + torch + numpy
  ```

  ```bash TypeScript theme={null}
  npm install getpatter onnxruntime-node@~1.18.0
  # Plus a DeepFilterNet ONNX model file you obtain separately.
  ```
</CodeGroup>

<Note>
  **TypeScript caveat.** DeepFilterNet does not ship an official ONNX export for Node.js at time of writing. The TS filter targets `onnxruntime-node` and loads any user-supplied `deepfilternet.onnx` you point it at. If you don't pass a `modelPath`, the filter logs a one-time warning and passes audio through unchanged — Patter never fakes enhancement. Once a stable community ONNX export with a streaming-friendly graph is published, point `modelPath` at it.
</Note>

## Constructor

<CodeGroup>
  ```python Python theme={null}
  from getpatter.providers.deepfilternet_filter import DeepFilterNetFilter

  filt = DeepFilterNetFilter(
      model_base_dir=None,        # None = use the bundled DeepFilterNet3 model
      atten_lim_db=None,          # optional attenuation cap in dB
  )
  ```

  ```typescript TypeScript theme={null}
  import { DeepFilterNetFilter } from "getpatter";

  const filt = new DeepFilterNetFilter({
    modelPath: "/abs/path/to/deepfilternet.onnx",  // omit for pass-through
    silenceWarnings: false,
  });
  ```
</CodeGroup>

## Usage in a pipeline agent

Plug it into `phone.agent(audio_filter=...)` / `audioFilter:`:

<CodeGroup>
  ```python Python theme={null}
  import asyncio
  from getpatter import Patter, Twilio, DeepgramSTT, AnthropicLLM, ElevenLabsTTS
  from getpatter.providers.deepfilternet_filter import DeepFilterNetFilter

  phone = Patter(carrier=Twilio(), phone_number="+15550001234")

  filt = DeepFilterNetFilter()

  agent = phone.agent(
      stt=DeepgramSTT(),
      llm=AnthropicLLM(),
      tts=ElevenLabsTTS(voice_id="rachel"),
      audio_filter=filt,                        # pre-STT noise suppression
      system_prompt="You are a helpful assistant.",
  )

  asyncio.run(phone.serve(agent))
  ```

  ```typescript TypeScript theme={null}
  import {
    Patter,
    Twilio,
    DeepgramSTT,
    AnthropicLLM,
    ElevenLabsTTS,
    DeepFilterNetFilter,
  } from "getpatter";

  const phone = new Patter({ carrier: new Twilio(), phoneNumber: "+15550001234" });

  const filt = new DeepFilterNetFilter({ modelPath: "/abs/path/to/deepfilternet.onnx" });

  const agent = phone.agent({
    stt: new DeepgramSTT(),
    llm: new AnthropicLLM(),
    tts: new ElevenLabsTTS({ voiceId: "rachel" }),
    audioFilter: filt,
    systemPrompt: "You are a helpful assistant.",
  });

  await phone.serve({ agent });
  ```
</CodeGroup>

See the [`audio_filter` parameter on Agents](/python-sdk/agents) (pipeline mode only).

## Resampling

DeepFilterNet operates at 48 kHz. Patter's pipeline-mode audio bus runs at 16 kHz. The filter resamples up before inference and back down after, so callers see a filter that preserves the input sample rate.

* **Python:** linear-interpolation resampler. Per-chunk; the boundary artefact is inaudible in practice.
* **TypeScript:** `StatefulResampler` from `audio/transcoding` so chunk-boundary samples are not silently discarded. Resamplers are flushed on `close()`.

## When to use DeepFilterNet vs alternatives

| Use DeepFilterNet when…                              | Use [Krisp](/python-sdk/providers/krisp-filter) when…                             | Skip filtering when…                                                     |
| ---------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
| You want OSS noise suppression with no licence step. | You need best-in-class commercial-grade suppression and you have a Krisp licence. | The line is clean (typical broadband VoIP / mobile in quiet conditions). |

## Notes

* On any internal error the filter logs and returns the **original** PCM unchanged — the call audio path is never broken.
* Install footprint matters: the Python extra adds `torch` (\~2 GB). For a smaller deploy where Python can't ship `torch`, use [Krisp](/python-sdk/providers/krisp-filter) (proprietary) or the (truly tiny) `audio_filter=None` baseline.
* The TS filter is a faithful pass-through when no ONNX model is supplied — by design, so tests and audio-quality metrics stay truthful.

## What's Next

<CardGroup cols={2}>
  <Card title="Agents" icon="user-gear" href="/python-sdk/agents">The `audio_filter` parameter on `phone.agent(...)`.</Card>
  <Card title="Krisp Filter" icon="filter" href="/python-sdk/providers/krisp-filter">Proprietary commercial noise suppression.</Card>
  <Card title="Silero VAD" icon="wave-square" href="/python-sdk/providers/silero-vad">Voice activity detection downstream of the filter.</Card>
  <Card title="Pipeline mode" icon="microphone" href="/python-sdk/stt">STT + LLM + TTS composition.</Card>
</CardGroup>