diff --git a/README.md b/README.md
index c21f15d..b289423 100644
--- a/README.md
+++ b/README.md
@@ -13,10 +13,15 @@ FalkorDB Python client
 
 see [docs](http://falkordb-py.readthedocs.io/)
 
-## Installation
-```sh
-pip install FalkorDB
-```
+## Installation
+```sh
+pip install FalkorDB
+```
+
+Embedded mode (local in-process server via optional binaries):
+```sh
+pip install "FalkorDB[lite]"
+```
 
 ## Usage
 
@@ -32,8 +37,8 @@ Or use [FalkorDB Cloud](https://app.falkordb.cloud)
 ```python
 from falkordb import FalkorDB
 
-# Connect to FalkorDB
-db = FalkorDB(host='localhost', port=6379)
+# Connect to FalkorDB
+db = FalkorDB(host='localhost', port=6379)
 
 # Select the social graph
 g = db.select_graph('social')
@@ -49,9 +54,14 @@ nodes = g.ro_query('MATCH (n) RETURN n LIMIT 10').result_set
 # Copy the Graph
 copy_graph = g.copy('social_copy')
 
-# Delete the Graph
-g.delete()
-```
+# Delete the Graph
+g.delete()
+
+# Embedded FalkorDB (no external server)
+with FalkorDB(embedded=True, db_path="/tmp/social.rdb") as embedded_db:
+    eg = embedded_db.select_graph("embedded_social")
+    eg.query('CREATE (:Person {name: "Alice"})')
+```
 
 ### Asynchronous Example
 
@@ -63,8 +73,8 @@ from redis.asyncio import BlockingConnectionPool
 async def main():
 
     # Connect to FalkorDB
-    pool = BlockingConnectionPool(max_connections=16, timeout=None, decode_responses=True)
-    db = FalkorDB(connection_pool=pool)
+    pool = BlockingConnectionPool(max_connections=16, timeout=None, decode_responses=True)
+    db = FalkorDB(connection_pool=pool)
     
     # Select the social graph
     g = db.select_graph('social')
@@ -90,8 +100,13 @@ async def main():
     print(f"Created Alice: {results[1].result_set[0][0]}")
     print(f"Created Bob: {results[2].result_set[0][0]}")
     
-    # Close the connection when done
-    await pool.aclose()
+    # Close the connection when done
+    await pool.aclose()
+
+    # Embedded mode (same API)
+    async with FalkorDB(embedded=True) as embedded_db:
+        embedded_graph = embedded_db.select_graph("embedded_social")
+        await embedded_graph.query('CREATE (:Person {name: "Bob"})')
 
 # Run the async example
 if __name__ == "__main__":
diff --git a/falkordb/asyncio/falkordb.py b/falkordb/asyncio/falkordb.py
index dba7199..d37b5d7 100644
--- a/falkordb/asyncio/falkordb.py
+++ b/falkordb/asyncio/falkordb.py
@@ -1,3 +1,4 @@
+import asyncio
 from typing import List, Optional, Union
 
 import redis.asyncio as redis  # type: ignore[import-not-found]
@@ -31,6 +32,8 @@ class FalkorDB:
         print(node.properties['name'])
     """
 
+    _embedded_server = None
+
     def __init__(
         self,
         host="localhost",
@@ -70,41 +73,89 @@ def __init__(
         reinitialize_steps=5,
         read_from_replicas=False,
         address_remap=None,
+        embedded=False,
+        db_path=None,
+        embedded_config=None,
+        startup_timeout=10.0,
+        connection_acquire_timeout=5.0,
     ):
+        self._embedded_server = None
+
+        if embedded:
+            from ..lite.server import EmbeddedServer
+
+            if max_connections is None:
+                max_connections = 16
+
+            server = EmbeddedServer(
+                db_path=db_path,
+                config=embedded_config,
+                startup_timeout=startup_timeout,
+            )
+            self._embedded_server = server
+            connection_pool = redis.BlockingConnectionPool(
+                connection_class=redis.UnixDomainSocketConnection,
+                path=server.unix_socket_path,
+                max_connections=max_connections,
+                timeout=connection_acquire_timeout,
+                socket_timeout=socket_timeout,
+                socket_connect_timeout=socket_connect_timeout,
+                socket_keepalive=socket_keepalive,
+                socket_keepalive_options=socket_keepalive_options,
+                encoding=encoding,
+                encoding_errors=encoding_errors,
+                decode_responses=True,
+                retry_on_error=retry_on_error,
+                retry=retry,
+                health_check_interval=health_check_interval,
+                client_name=client_name,
+                lib_name=lib_name,
+                lib_version=lib_version,
+                username=username,
+                password=password,
+                credential_provider=credential_provider,
+                protocol=protocol,
+            )
 
-        conn = redis.Redis(
-            host=host,
-            port=port,
-            db=0,
-            password=password,
-            socket_timeout=socket_timeout,
-            socket_connect_timeout=socket_connect_timeout,
-            socket_keepalive=socket_keepalive,
-            socket_keepalive_options=socket_keepalive_options,
-            connection_pool=connection_pool,
-            unix_socket_path=unix_socket_path,
-            encoding=encoding,
-            encoding_errors=encoding_errors,
-            decode_responses=True,
-            retry_on_error=retry_on_error,
-            ssl=ssl,
-            ssl_keyfile=ssl_keyfile,
-            ssl_certfile=ssl_certfile,
-            ssl_cert_reqs=ssl_cert_reqs,
-            ssl_ca_certs=ssl_ca_certs,
-            ssl_ca_data=ssl_ca_data,
-            ssl_check_hostname=ssl_check_hostname,
-            max_connections=max_connections,
-            single_connection_client=single_connection_client,
-            health_check_interval=health_check_interval,
-            client_name=client_name,
-            driver_info=DriverInfo(lib_name, lib_version or get_package_version()),
-            username=username,
-            retry=retry,
-            redis_connect_func=connect_func,
-            credential_provider=credential_provider,
-            protocol=protocol,
-        )
+        if embedded:
+            conn = redis.Redis(
+                connection_pool=connection_pool,
+                single_connection_client=single_connection_client,
+            )
+        else:
+            conn = redis.Redis(
+                host=host,
+                port=port,
+                db=0,
+                password=password,
+                socket_timeout=socket_timeout,
+                socket_connect_timeout=socket_connect_timeout,
+                socket_keepalive=socket_keepalive,
+                socket_keepalive_options=socket_keepalive_options,
+                connection_pool=connection_pool,
+                unix_socket_path=unix_socket_path,
+                encoding=encoding,
+                encoding_errors=encoding_errors,
+                decode_responses=True,
+                retry_on_error=retry_on_error,
+                ssl=ssl,
+                ssl_keyfile=ssl_keyfile,
+                ssl_certfile=ssl_certfile,
+                ssl_cert_reqs=ssl_cert_reqs,
+                ssl_ca_certs=ssl_ca_certs,
+                ssl_ca_data=ssl_ca_data,
+                ssl_check_hostname=ssl_check_hostname,
+                max_connections=max_connections,
+                single_connection_client=single_connection_client,
+                health_check_interval=health_check_interval,
+                client_name=client_name,
+                driver_info=DriverInfo(lib_name, lib_version or get_package_version()),
+                username=username,
+                retry=retry,
+                redis_connect_func=connect_func,
+                credential_provider=credential_provider,
+                protocol=protocol,
+            )
 
         if Is_Cluster(conn):
             conn = Cluster_Conn(
@@ -215,9 +266,8 @@ async def config_set(self, name: str, value=None) -> None:
         return await self.connection.execute_command(CONFIG_CMD, "SET", name, value)
 
     async def aclose(self) -> None:
-        """
-        Close the underlying connection(s).
-        """
+        """Close the underlying connection(s) and stop the embedded server
+        if present."""
 
         try:
             await self.connection.aclose()
@@ -225,6 +275,11 @@ async def aclose(self) -> None:
             # best-effort close — don't raise on Redis errors
             pass
 
+        server = getattr(self, "_embedded_server", None)
+        if server is not None:
+            await asyncio.to_thread(server.stop)
+            self._embedded_server = None
+
     async def __aenter__(self) -> "FalkorDB":
         """Return self to support async with-statement usage."""
 
diff --git a/falkordb/falkordb.py b/falkordb/falkordb.py
index b3605b8..f706371 100644
--- a/falkordb/falkordb.py
+++ b/falkordb/falkordb.py
@@ -31,6 +31,8 @@ class FalkorDB:
         print(node.properties['name'])
     """
 
+    _embedded_server = None
+
     def __init__(
         self,
         host="localhost",
@@ -78,47 +80,94 @@ def __init__(
         dynamic_startup_nodes=True,
         url=None,
         address_remap=None,
+        embedded=False,
+        db_path=None,
+        embedded_config=None,
+        startup_timeout=10.0,
     ):
+        self._embedded_server = None
+
+        if embedded:
+            from .lite.server import EmbeddedServer
+
+            if max_connections is None:
+                max_connections = 16
+
+            server = EmbeddedServer(
+                db_path=db_path,
+                config=embedded_config,
+                startup_timeout=startup_timeout,
+            )
+            self._embedded_server = server
+
+            connection_pool = redis.ConnectionPool(
+                connection_class=redis.UnixDomainSocketConnection,
+                path=server.unix_socket_path,
+                max_connections=max_connections,
+                socket_timeout=socket_timeout,
+                socket_connect_timeout=socket_connect_timeout,
+                socket_keepalive=socket_keepalive,
+                socket_keepalive_options=socket_keepalive_options,
+                encoding=encoding,
+                encoding_errors=encoding_errors,
+                decode_responses=True,
+                retry_on_error=retry_on_error,
+                retry=retry,
+                health_check_interval=health_check_interval,
+                client_name=client_name,
+                lib_name=lib_name,
+                lib_version=lib_version,
+                username=username,
+                password=password,
+                credential_provider=credential_provider,
+                protocol=protocol,
+            )
 
-        conn = redis.Redis(
-            host=host,
-            port=port,
-            db=0,
-            password=password,
-            socket_timeout=socket_timeout,
-            socket_connect_timeout=socket_connect_timeout,
-            socket_keepalive=socket_keepalive,
-            socket_keepalive_options=socket_keepalive_options,
-            connection_pool=connection_pool,
-            unix_socket_path=unix_socket_path,
-            encoding=encoding,
-            encoding_errors=encoding_errors,
-            decode_responses=True,
-            retry_on_error=retry_on_error,
-            ssl=ssl,
-            ssl_keyfile=ssl_keyfile,
-            ssl_certfile=ssl_certfile,
-            ssl_cert_reqs=ssl_cert_reqs,
-            ssl_ca_certs=ssl_ca_certs,
-            ssl_ca_path=ssl_ca_path,
-            ssl_ca_data=ssl_ca_data,
-            ssl_check_hostname=ssl_check_hostname,
-            ssl_password=ssl_password,
-            ssl_validate_ocsp=ssl_validate_ocsp,
-            ssl_validate_ocsp_stapled=ssl_validate_ocsp_stapled,
-            ssl_ocsp_context=ssl_ocsp_context,
-            ssl_ocsp_expected_cert=ssl_ocsp_expected_cert,
-            max_connections=max_connections,
-            single_connection_client=single_connection_client,
-            health_check_interval=health_check_interval,
-            client_name=client_name,
-            driver_info=DriverInfo(lib_name, lib_version or get_package_version()),
-            username=username,
-            retry=retry,
-            redis_connect_func=connect_func,
-            credential_provider=credential_provider,
-            protocol=protocol,
-        )
+        if embedded:
+            conn = redis.Redis(
+                connection_pool=connection_pool,
+                single_connection_client=single_connection_client,
+            )
+        else:
+            conn = redis.Redis(
+                host=host,
+                port=port,
+                db=0,
+                password=password,
+                socket_timeout=socket_timeout,
+                socket_connect_timeout=socket_connect_timeout,
+                socket_keepalive=socket_keepalive,
+                socket_keepalive_options=socket_keepalive_options,
+                connection_pool=connection_pool,
+                unix_socket_path=unix_socket_path,
+                encoding=encoding,
+                encoding_errors=encoding_errors,
+                decode_responses=True,
+                retry_on_error=retry_on_error,
+                ssl=ssl,
+                ssl_keyfile=ssl_keyfile,
+                ssl_certfile=ssl_certfile,
+                ssl_cert_reqs=ssl_cert_reqs,
+                ssl_ca_certs=ssl_ca_certs,
+                ssl_ca_path=ssl_ca_path,
+                ssl_ca_data=ssl_ca_data,
+                ssl_check_hostname=ssl_check_hostname,
+                ssl_password=ssl_password,
+                ssl_validate_ocsp=ssl_validate_ocsp,
+                ssl_validate_ocsp_stapled=ssl_validate_ocsp_stapled,
+                ssl_ocsp_context=ssl_ocsp_context,
+                ssl_ocsp_expected_cert=ssl_ocsp_expected_cert,
+                max_connections=max_connections,
+                single_connection_client=single_connection_client,
+                health_check_interval=health_check_interval,
+                client_name=client_name,
+                driver_info=DriverInfo(lib_name, lib_version or get_package_version()),
+                username=username,
+                retry=retry,
+                redis_connect_func=connect_func,
+                credential_provider=credential_provider,
+                protocol=protocol,
+            )
 
         if Is_Sentinel(conn):
             self.sentinel, self.service_name = Sentinel_Conn(conn, ssl)
@@ -142,6 +191,30 @@ def __init__(
         self.flushdb = conn.flushdb
         self.execute_command = conn.execute_command
 
+    def close(self) -> None:
+        """Close the underlying connection(s) and stop the embedded server
+        if present."""
+
+        try:
+            self.connection.close()
+        except RedisError:
+            # best-effort close — don't raise on Redis errors
+            pass
+
+        server = getattr(self, "_embedded_server", None)
+        if server is not None:
+            server.stop()
+            self._embedded_server = None
+
+    def __enter__(self) -> "FalkorDB":
+        """Return self to support usage in a with-statement."""
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Close the connection when exiting a with-statement."""
+        self.close()
+
     @classmethod
     def from_url(cls, url: str, **kwargs) -> "FalkorDB":
         """
@@ -233,26 +306,6 @@ def config_set(self, name: str, value=None) -> None:
 
         return self.connection.execute_command(CONFIG_CMD, "SET", name, value)
 
-    def close(self) -> None:
-        """
-        Close the underlying connection(s).
-        """
-
-        try:
-            self.connection.close()
-        except RedisError:
-            # best-effort close — don't raise on Redis errors
-            pass
-
-    def __enter__(self) -> "FalkorDB":
-        """Return self to support usage in a with-statement."""
-
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
-        """Close the connection when exiting a with-statement."""
-        self.close()
-
     # GRAPH.UDF LOAD [REPLACE] <lib> <script>
     def udf_load(self, name: str, script: str, replace: bool = False):
         """
diff --git a/falkordb/lite/__init__.py b/falkordb/lite/__init__.py
new file mode 100644
index 0000000..e5d812e
--- /dev/null
+++ b/falkordb/lite/__init__.py
@@ -0,0 +1,6 @@
+"""
+Embedded FalkorDB support.
+
+Install with:
+    pip install falkordb[lite]
+"""
diff --git a/falkordb/lite/binaries.py b/falkordb/lite/binaries.py
new file mode 100644
index 0000000..6b8f801
--- /dev/null
+++ b/falkordb/lite/binaries.py
@@ -0,0 +1,36 @@
+"""Resolve embedded binaries provided by the optional falkordb-bin package."""
+
+from pathlib import Path
+
+
+class BinaryNotFoundError(ImportError):
+    """Raised when embedded binaries are missing."""
+
+
+def _require_bin_package():
+    try:
+        import falkordb_bin
+    except ImportError as exc:
+        raise BinaryNotFoundError(
+            "Embedded FalkorDB requires the optional 'lite' extra. "
+            "Install with: pip install falkordb[lite]"
+        ) from exc
+    return falkordb_bin
+
+
+def get_redis_server_path() -> Path:
+    """Return path to the embedded redis-server binary."""
+    falkordb_bin = _require_bin_package()
+    path = Path(falkordb_bin.get_redis_server())
+    if not path.exists():
+        raise BinaryNotFoundError(f"redis-server binary was not found at: {path}")
+    return path
+
+
+def get_falkordb_module_path() -> Path:
+    """Return path to the embedded FalkorDB module binary."""
+    falkordb_bin = _require_bin_package()
+    path = Path(falkordb_bin.get_falkordb_module())
+    if not path.exists():
+        raise BinaryNotFoundError(f"FalkorDB module binary was not found at: {path}")
+    return path
diff --git a/falkordb/lite/config.py b/falkordb/lite/config.py
new file mode 100644
index 0000000..5fc9f44
--- /dev/null
+++ b/falkordb/lite/config.py
@@ -0,0 +1,73 @@
+"""Generate Redis configuration used by embedded FalkorDB."""
+
+import os
+from pathlib import Path
+from typing import Any, Optional
+
+DEFAULT_CONFIG: dict[str, Any] = {
+    "bind": "127.0.0.1",
+    "port": "0",
+    "save": "",
+    "appendonly": "no",
+    "protected-mode": "yes",
+    "loglevel": "warning",
+    "databases": "16",
+}
+
+PERSISTENT_OVERRIDES: dict[str, Any] = {
+    "save": [("900", "1"), ("300", "10"), ("60", "10000")],
+    "appendonly": "yes",
+    "appendfsync": "everysec",
+}
+
+
+def generate_config(
+    falkordb_module_path: Path,
+    db_path: Optional[str] = None,
+    unix_socket_path: Optional[str] = None,
+    user_config: Optional[dict[str, Any]] = None,
+) -> str:
+    """Return redis.conf content for embedded mode."""
+    config: dict[str, Any] = dict(DEFAULT_CONFIG)
+
+    if db_path:
+        abs_db_path = os.path.abspath(db_path)
+        db_dir = os.path.dirname(abs_db_path)
+        db_file = os.path.basename(abs_db_path)
+        os.makedirs(db_dir, exist_ok=True)
+        config["dir"] = db_dir
+        config["dbfilename"] = db_file
+        config.update(PERSISTENT_OVERRIDES)
+
+    if unix_socket_path:
+        config["unixsocket"] = unix_socket_path
+        config["unixsocketperm"] = "700"
+        config["port"] = "0"
+
+    if user_config:
+        if "loadmodule" in user_config:
+            raise ValueError("'loadmodule' is reserved and cannot be overridden")
+        config.update(user_config)
+
+    # Ensure port remains disabled when using unix socket
+    # (must be after user_config to prevent accidental override)
+    if unix_socket_path:
+        config["port"] = "0"
+
+    config["loadmodule"] = str(falkordb_module_path)
+
+    lines = []
+    for key, value in config.items():
+        if key == "save" and isinstance(value, list):
+            for rule in value:
+                if isinstance(rule, (tuple, list)) and len(rule) == 2:
+                    lines.append(f"save {rule[0]} {rule[1]}")
+                else:
+                    lines.append(f"save {rule}")
+            continue
+        if isinstance(value, str) and value == "":
+            lines.append(f'{key} ""')
+            continue
+        lines.append(f"{key} {value}")
+
+    return "\n".join(lines) + "\n"
diff --git a/falkordb/lite/server.py b/falkordb/lite/server.py
new file mode 100644
index 0000000..2c4e17d
--- /dev/null
+++ b/falkordb/lite/server.py
@@ -0,0 +1,144 @@
+"""Embedded redis-server lifecycle management for FalkorDB."""
+
+import atexit
+import io
+import os
+import shutil
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+import redis
+
+from .binaries import get_falkordb_module_path, get_redis_server_path
+from .config import generate_config
+
+
+class EmbeddedServerError(RuntimeError):
+    """Raised when the embedded server cannot be started or managed."""
+
+
+class EmbeddedServer:
+    """Manage an embedded redis-server process configured with FalkorDB module."""
+
+    def __init__(
+        self,
+        db_path: Optional[str] = None,
+        config: Optional[dict[str, Any]] = None,
+        startup_timeout: float = 10.0,
+    ):
+        self._process: Optional[subprocess.Popen[bytes]] = None
+        self._stderr_file: Optional[io.TextIOWrapper] = None
+        self._db_path = db_path
+        self._startup_timeout = startup_timeout
+        self._tmpdir = tempfile.mkdtemp(prefix="falkordb_")
+        self._socket_path = os.path.join(self._tmpdir, "falkordb.sock")
+        self._config_path = os.path.join(self._tmpdir, "redis.conf")
+        self._stderr_path = os.path.join(self._tmpdir, "redis.stderr.log")
+
+        redis_server = get_redis_server_path()
+        falkordb_module = get_falkordb_module_path()
+
+        config_content = generate_config(
+            falkordb_module_path=falkordb_module,
+            db_path=db_path,
+            unix_socket_path=self._socket_path,
+            user_config=config,
+        )
+        Path(self._config_path).write_text(config_content, encoding="utf-8")
+
+        self._start(redis_server)
+        atexit.register(self.stop)
+
+    def _start(self, redis_server: Path) -> None:
+        self._stderr_file = open(self._stderr_path, "w", encoding="utf-8")
+        self._process = subprocess.Popen(  # noqa: S603
+            [str(redis_server), self._config_path],
+            stdout=subprocess.DEVNULL,
+            stderr=self._stderr_file,
+        )
+
+        deadline = time.monotonic() + self._startup_timeout
+        while time.monotonic() < deadline:
+            if self._process.poll() is not None:
+                stderr = self._read_stderr()
+                self._close_stderr_file()
+                raise EmbeddedServerError(
+                    f"redis-server exited with code "
+                    f"{self._process.returncode}: {stderr}"
+                )
+
+            if os.path.exists(self._socket_path):
+                try:
+                    conn = redis.Redis(
+                        unix_socket_path=self._socket_path, decode_responses=True
+                    )
+                    try:
+                        conn.ping()
+                        self._close_stderr_file()
+                        return
+                    finally:
+                        conn.close()
+                except redis.ConnectionError:
+                    pass
+            time.sleep(0.05)
+
+        self.stop()
+        raise EmbeddedServerError(
+            f"redis-server did not start within {self._startup_timeout} seconds"
+        )
+
+    @property
+    def unix_socket_path(self) -> str:
+        return self._socket_path
+
+    def stop(self) -> None:
+        """Stop embedded redis-server and cleanup temporary files."""
+        if self._process is not None and self._process.poll() is None:
+            conn = None
+            try:
+                conn = redis.Redis(
+                    unix_socket_path=self._socket_path, decode_responses=True
+                )
+                try:
+                    conn.shutdown(nosave=not bool(self._db_path))
+                except redis.exceptions.ConnectionError:
+                    # redis-server can drop the connection as part of normal shutdown
+                    pass
+            except Exception:
+                self._process.terminate()
+            finally:
+                if conn is not None:
+                    conn.close()
+
+            try:
+                self._process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self._process.kill()
+                self._process.wait(timeout=5)
+
+        self._process = None
+        self._close_stderr_file()
+        if os.path.isdir(self._tmpdir):
+            shutil.rmtree(self._tmpdir, ignore_errors=True)
+
+    def _read_stderr(self) -> str:
+        if self._stderr_file is not None and not self._stderr_file.closed:
+            self._stderr_file.flush()
+        if not os.path.exists(self._stderr_path):
+            return ""
+        return Path(self._stderr_path).read_text(encoding="utf-8", errors="replace")
+
+    def _close_stderr_file(self) -> None:
+        if self._stderr_file is not None and not self._stderr_file.closed:
+            self._stderr_file.close()
+
+    def __del__(self):
+        try:
+            self.stop()
+        except Exception:
+            # Best-effort cleanup: __del__ must never raise, and during
+            # interpreter shutdown resources may already be torn down.
+            pass
diff --git a/pyproject.toml b/pyproject.toml
index 017ab74..b1478ce 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -31,6 +31,9 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+lite = [
+    "falkordb-bin>=1.4.0,<2.0.0",
+]
 test = [
     "pytest-cov>=7.0.0",
     "pytest>=9.0.2",
diff --git a/tests/test_embedded.py b/tests/test_embedded.py
new file mode 100644
index 0000000..41ee971
--- /dev/null
+++ b/tests/test_embedded.py
@@ -0,0 +1,114 @@
+import sys
+
+import pytest
+
+from falkordb import FalkorDB
+from falkordb.lite.binaries import BinaryNotFoundError, get_redis_server_path
+from falkordb.lite.config import generate_config
+
+
+class DummyServer:
+    def __init__(self, db_path=None, config=None, startup_timeout=10.0):
+        self.db_path = db_path
+        self.config = config
+        self.startup_timeout = startup_timeout
+        self.unix_socket_path = "/tmp/falkordb-test.sock"
+        self.stopped = False
+
+    def stop(self):
+        self.stopped = True
+
+
+def test_embedded_defaults_to_pool_of_16(monkeypatch):
+    dummy_server = DummyServer()
+
+    def fake_server(*args, **kwargs):
+        return dummy_server
+
+    monkeypatch.setattr("falkordb.lite.server.EmbeddedServer", fake_server)
+    monkeypatch.setattr("falkordb.falkordb.Is_Sentinel", lambda _conn: False)
+    monkeypatch.setattr("falkordb.falkordb.Is_Cluster", lambda _conn: False)
+
+    db = FalkorDB(embedded=True)
+    assert db.connection.connection_pool.max_connections == 16
+    assert (
+        db.connection.connection_pool.connection_kwargs["path"]
+        == dummy_server.unix_socket_path
+    )
+
+    db.close()
+    assert dummy_server.stopped is True
+
+
+def test_embedded_passes_config_and_db_path(monkeypatch):
+    observed = {}
+
+    def fake_server(*args, **kwargs):
+        observed["kwargs"] = kwargs
+        return DummyServer(*args, **kwargs)
+
+    monkeypatch.setattr("falkordb.lite.server.EmbeddedServer", fake_server)
+    monkeypatch.setattr("falkordb.falkordb.Is_Sentinel", lambda _conn: False)
+    monkeypatch.setattr("falkordb.falkordb.Is_Cluster", lambda _conn: False)
+
+    db = FalkorDB(
+        embedded=True,
+        db_path="/tmp/demo.db",
+        embedded_config={"maxmemory": "1gb"},
+        startup_timeout=12.5,
+        max_connections=32,
+    )
+
+    assert observed["kwargs"]["db_path"] == "/tmp/demo.db"
+    assert observed["kwargs"]["config"] == {"maxmemory": "1gb"}
+    assert observed["kwargs"]["startup_timeout"] == 12.5
+    assert db.connection.connection_pool.max_connections == 32
+    db.close()
+
+
+def test_context_manager_closes_embedded_server(monkeypatch):
+    dummy_server = DummyServer()
+    monkeypatch.setattr(
+        "falkordb.lite.server.EmbeddedServer", lambda *args, **kwargs: dummy_server
+    )
+    monkeypatch.setattr("falkordb.falkordb.Is_Sentinel", lambda _conn: False)
+    monkeypatch.setattr("falkordb.falkordb.Is_Cluster", lambda _conn: False)
+
+    with FalkorDB(embedded=True):
+        pass
+
+    assert dummy_server.stopped is True
+
+
+def test_generate_config_with_persistence(tmp_path):
+    db_file = tmp_path / "embedded.rdb"
+    conf = generate_config(
+        falkordb_module_path=tmp_path / "falkordb.so",
+        db_path=str(db_file),
+        unix_socket_path="/tmp/test.sock",
+        user_config={"maxmemory": "1gb"},
+    )
+
+    assert f"dir {tmp_path}" in conf
+    assert "dbfilename embedded.rdb" in conf
+    assert "save 900 1" in conf
+    assert "save 300 10" in conf
+    assert "save 60 10000" in conf
+    assert "appendonly yes" in conf
+    assert "unixsocket /tmp/test.sock" in conf
+    assert "maxmemory 1gb" in conf
+
+
+def test_generate_config_rejects_loadmodule_override(tmp_path):
+    with pytest.raises(ValueError):
+        generate_config(
+            falkordb_module_path=tmp_path / "falkordb.so",
+            user_config={"loadmodule": "/tmp/other.so"},
+        )
+
+
+def test_missing_lite_dependency_error(monkeypatch):
+    monkeypatch.setitem(sys.modules, "falkordb_bin", None)
+
+    with pytest.raises(BinaryNotFoundError):
+        get_redis_server_path()
diff --git a/tests/test_embedded_async.py b/tests/test_embedded_async.py
new file mode 100644
index 0000000..8dcb68b
--- /dev/null
+++ b/tests/test_embedded_async.py
@@ -0,0 +1,62 @@
+import pytest
+
+from falkordb.asyncio import FalkorDB
+
+
+class DummyServer:
+    def __init__(self, db_path=None, config=None, startup_timeout=10.0):
+        self.db_path = db_path
+        self.config = config
+        self.startup_timeout = startup_timeout
+        self.unix_socket_path = "/tmp/falkordb-async-test.sock"
+        self.stopped = False
+
+    def stop(self):
+        self.stopped = True
+
+
+@pytest.mark.asyncio
+async def test_async_embedded_defaults_to_pool_of_16(monkeypatch):
+    dummy_server = DummyServer()
+    monkeypatch.setattr(
+        "falkordb.lite.server.EmbeddedServer", lambda *args, **kwargs: dummy_server
+    )
+    monkeypatch.setattr("falkordb.asyncio.falkordb.Is_Cluster", lambda _conn: False)
+
+    db = FalkorDB(embedded=True)
+    assert db.connection.connection_pool.max_connections == 16
+    assert db.connection.connection_pool.timeout == 5.0
+    assert (
+        db.connection.connection_pool.connection_kwargs["path"]
+        == dummy_server.unix_socket_path
+    )
+
+    await db.aclose()
+    assert dummy_server.stopped is True
+
+
+@pytest.mark.asyncio
+async def test_async_embedded_uses_custom_acquire_timeout(monkeypatch):
+    dummy_server = DummyServer()
+    monkeypatch.setattr(
+        "falkordb.lite.server.EmbeddedServer", lambda *args, **kwargs: dummy_server
+    )
+    monkeypatch.setattr("falkordb.asyncio.falkordb.Is_Cluster", lambda _conn: False)
+
+    db = FalkorDB(embedded=True, connection_acquire_timeout=1.25)
+    assert db.connection.connection_pool.timeout == 1.25
+    await db.aclose()
+
+
+@pytest.mark.asyncio
+async def test_async_context_manager_closes_server(monkeypatch):
+    dummy_server = DummyServer()
+    monkeypatch.setattr(
+        "falkordb.lite.server.EmbeddedServer", lambda *args, **kwargs: dummy_server
+    )
+    monkeypatch.setattr("falkordb.asyncio.falkordb.Is_Cluster", lambda _conn: False)
+
+    async with FalkorDB(embedded=True):
+        pass
+
+    assert dummy_server.stopped is True
diff --git a/tests/test_lite_binaries.py b/tests/test_lite_binaries.py
new file mode 100644
index 0000000..f07887b
--- /dev/null
+++ b/tests/test_lite_binaries.py
@@ -0,0 +1,72 @@
+import sys
+
+import pytest
+
+from falkordb.lite.binaries import (
+    BinaryNotFoundError,
+    get_falkordb_module_path,
+    get_redis_server_path,
+)
+
+
+class DummyBinModule:
+    def __init__(self, redis_path: str, module_path: str):
+        self._redis_path = redis_path
+        self._module_path = module_path
+
+    def get_redis_server(self):
+        return self._redis_path
+
+    def get_falkordb_module(self):
+        return self._module_path
+
+
+def test_get_redis_server_path_success(monkeypatch, tmp_path):
+    redis_path = tmp_path / "redis-server"
+    redis_path.write_text("bin", encoding="utf-8")
+    module = DummyBinModule(str(redis_path), str(tmp_path / "falkordb.so"))
+    monkeypatch.setitem(sys.modules, "falkordb_bin", module)
+
+    path = get_redis_server_path()
+    assert path == redis_path
+
+
+def test_get_redis_server_path_missing_file(monkeypatch, tmp_path):
+    module = DummyBinModule(
+        str(tmp_path / "missing-redis"), str(tmp_path / "falkordb.so")
+    )
+    monkeypatch.setitem(sys.modules, "falkordb_bin", module)
+
+    with pytest.raises(BinaryNotFoundError, match="redis-server binary was not found"):
+        get_redis_server_path()
+
+
+def test_get_falkordb_module_path_success(monkeypatch, tmp_path):
+    module_path = tmp_path / "falkordb.so"
+    module_path.write_text("so", encoding="utf-8")
+    module = DummyBinModule(str(tmp_path / "redis-server"), str(module_path))
+    monkeypatch.setitem(sys.modules, "falkordb_bin", module)
+
+    path = get_falkordb_module_path()
+    assert path == module_path
+
+
+def test_get_falkordb_module_path_missing_file(monkeypatch, tmp_path):
+    module = DummyBinModule(
+        str(tmp_path / "redis-server"), str(tmp_path / "missing-module.so")
+    )
+    monkeypatch.setitem(sys.modules, "falkordb_bin", module)
+
+    with pytest.raises(
+        BinaryNotFoundError, match="FalkorDB module binary was not found"
+    ):
+        get_falkordb_module_path()
+
+
+def test_missing_lite_dependency_raises(monkeypatch):
+    monkeypatch.delitem(sys.modules, "falkordb_bin", raising=False)
+
+    with pytest.raises(
+        BinaryNotFoundError, match="Install with: pip install falkordb\\[lite\\]"
+    ):
+        get_redis_server_path()
diff --git a/tests/test_lite_server.py b/tests/test_lite_server.py
new file mode 100644
index 0000000..104a54e
--- /dev/null
+++ b/tests/test_lite_server.py
@@ -0,0 +1,231 @@
+import gc
+import subprocess
+
+import pytest
+import redis
+
+from falkordb.lite.server import EmbeddedServer, EmbeddedServerError
+
+
+class DummyProcess:
+    def __init__(self, poll_result=None, wait_raises=False):
+        self._poll_result = poll_result
+        self.returncode = 7 if poll_result is not None else None
+        self.wait_raises = wait_raises
+        self._wait_raise_count = 0
+        self.terminated = False
+        self.killed = False
+        self.wait_called = False
+
+    def poll(self):
+        return self._poll_result
+
+    def terminate(self):
+        self.terminated = True
+
+    def wait(self, timeout=None):
+        self.wait_called = True
+        if self.wait_raises and self._wait_raise_count == 0:
+            self._wait_raise_count += 1
+            raise subprocess.TimeoutExpired("redis-server", timeout)
+
+    def kill(self):
+        self.killed = True
+
+
+class DummyConn:
+    def __init__(self, shutdown_exc=None):
+        self.shutdown_exc = shutdown_exc
+        self.closed = False
+        self.ping_called = False
+
+    def shutdown(self, nosave=False):
+        if self.shutdown_exc is not None:
+            raise self.shutdown_exc
+
+    def ping(self):
+        self.ping_called = True
+
+    def close(self):
+        self.closed = True
+
+
+def _make_server(tmp_path):
+    server = EmbeddedServer.__new__(EmbeddedServer)
+    server._process = None
+    server._stderr_file = None
+    server._db_path = None
+    server._startup_timeout = 0.01
+    server._tmpdir = str(tmp_path)
+    server._socket_path = str(tmp_path / "falkordb.sock")
+    server._config_path = str(tmp_path / "redis.conf")
+    server._stderr_path = str(tmp_path / "redis.stderr.log")
+    return server
+
+
+def test_init_wires_config_and_registers_atexit(monkeypatch, tmp_path):
+    calls = {}
+    redis_server_path = tmp_path / "redis-server"
+    module_path = tmp_path / "falkordb.so"
+
+    monkeypatch.setattr(
+        "falkordb.lite.server.get_redis_server_path", lambda: redis_server_path
+    )
+    monkeypatch.setattr(
+        "falkordb.lite.server.get_falkordb_module_path", lambda: module_path
+    )
+
+    def fake_generate_config(**kwargs):
+        calls["generate_config"] = kwargs
+        return "port 0\n"
+
+    monkeypatch.setattr("falkordb.lite.server.generate_config", fake_generate_config)
+    monkeypatch.setattr(
+        "falkordb.lite.server.EmbeddedServer._start",
+        lambda self, redis_server: calls.update({"start": redis_server}),
+    )
+    monkeypatch.setattr(
+        "falkordb.lite.server.atexit.register", lambda fn: calls.update({"atexit": fn})
+    )
+
+    server = EmbeddedServer(
+        db_path="/tmp/demo.rdb", config={"maxmemory": "1gb"}, startup_timeout=3.0
+    )
+
+    assert calls["generate_config"]["falkordb_module_path"] == module_path
+    assert calls["generate_config"]["db_path"] == "/tmp/demo.rdb"
+    assert calls["generate_config"]["user_config"] == {"maxmemory": "1gb"}
+    assert calls["start"] == redis_server_path
+    assert calls["atexit"] == server.stop
+
+
+def test_start_raises_with_stderr_content(monkeypatch, tmp_path):
+    server = _make_server(tmp_path)
+
+    monkeypatch.setattr(
+        "falkordb.lite.server.subprocess.Popen",
+        lambda *args, **kwargs: DummyProcess(poll_result=1),
+    )
+    monkeypatch.setattr(server, "_read_stderr", lambda: "boom")
+
+    with pytest.raises(EmbeddedServerError, match="boom"):
+        server._start(tmp_path / "redis-server")
+
+
+def test_start_success_when_socket_is_ready(monkeypatch, tmp_path):
+    server = _make_server(tmp_path)
+    process = DummyProcess(poll_result=None)
+    conn = DummyConn()
+
+    monkeypatch.setattr(
+        "falkordb.lite.server.subprocess.Popen", lambda *args, **kwargs: process
+    )
+    monkeypatch.setattr(
+        "falkordb.lite.server.os.path.exists", lambda path: path == server._socket_path
+    )
+    monkeypatch.setattr(
+        "falkordb.lite.server.redis.Redis", lambda *args, **kwargs: conn
+    )
+
+    server._start(tmp_path / "redis-server")
+    assert conn.ping_called is True
+    assert conn.closed is True
+
+
+def test_start_timeout_calls_stop(monkeypatch, tmp_path):
+    server = _make_server(tmp_path)
+    process = DummyProcess(poll_result=None)
+    called = {"stop": False}
+
+    monkeypatch.setattr(
+        "falkordb.lite.server.subprocess.Popen", lambda *args, **kwargs: process
+    )
+    monkeypatch.setattr("falkordb.lite.server.os.path.exists", lambda path: False)
+    monotonic_values = iter([1.0, 1.0, 1.02])
+    monkeypatch.setattr(
+        "falkordb.lite.server.time.monotonic", lambda: next(monotonic_values)
+    )
+    monkeypatch.setattr("falkordb.lite.server.time.sleep", lambda _seconds: None)
+    monkeypatch.setattr(server, "stop", lambda: called.update({"stop": True}))
+
+    with pytest.raises(EmbeddedServerError, match="did not start within"):
+        server._start(tmp_path / "redis-server")
+    assert called["stop"] is True
+
+
+def test_stop_ignores_connection_error_on_shutdown(monkeypatch, tmp_path):
+    server = _make_server(tmp_path)
+    server._process = DummyProcess(poll_result=None)
+    conn = DummyConn(shutdown_exc=redis.exceptions.ConnectionError("expected"))
+
+    monkeypatch.setattr(
+        "falkordb.lite.server.redis.Redis", lambda *args, **kwargs: conn
+    )
+
+    server.stop()
+    assert conn.closed is True
+    assert server._process is None
+
+
+def test_stop_terminates_on_unexpected_shutdown_error(monkeypatch, tmp_path):
+    server = _make_server(tmp_path)
+    process = DummyProcess(poll_result=None)
+    server._process = process
+    conn = DummyConn(shutdown_exc=RuntimeError("unexpected"))
+
+    monkeypatch.setattr(
+        "falkordb.lite.server.redis.Redis", lambda *args, **kwargs: conn
+    )
+
+    server.stop()
+    assert process.terminated is True
+    assert conn.closed is True
+    assert server._process is None
+
+
+def test_stop_kills_process_on_wait_timeout(monkeypatch, tmp_path):
+    server = _make_server(tmp_path)
+    process = DummyProcess(poll_result=None, wait_raises=True)
+    server._process = process
+    conn = DummyConn()
+
+    monkeypatch.setattr(
+        "falkordb.lite.server.redis.Redis", lambda *args, **kwargs: conn
+    )
+
+    server.stop()
+    assert process.killed is True
+    assert process.wait_called is True
+
+
+def test_stop_noop_when_process_already_exited(tmp_path):
+    server = _make_server(tmp_path)
+    server._process = DummyProcess(poll_result=0)
+
+    server.stop()
+    assert server._process is None
+
+
+def test_read_stderr_flushes_open_file(tmp_path):
+    server = _make_server(tmp_path)
+    with open(tmp_path / "redis.stderr.log", "w", encoding="utf-8") as stderr_file:
+        stderr_file.write("stderr-text")
+        server._stderr_file = stderr_file
+
+        output = server._read_stderr()
+        assert output == "stderr-text"
+
+
+def test_read_stderr_returns_empty_when_file_missing(tmp_path):
+    server = _make_server(tmp_path)
+    assert server._read_stderr() == ""
+
+
+def test_del_swallows_stop_exceptions(tmp_path, monkeypatch):
+    server = _make_server(tmp_path)
+    monkeypatch.setattr(
+        server, "stop", lambda: (_ for _ in ()).throw(RuntimeError("boom"))
+    )
+
+    del server
+    gc.collect()
diff --git a/uv.lock b/uv.lock
index 9d90961..5fe9510 100644
--- a/uv.lock
+++ b/uv.lock
@@ -297,6 +297,9 @@ dependencies = [
 ]
 
 [package.optional-dependencies]
+lite = [
+    { name = "falkordb-bin" },
+]
 test = [
     { name = "pytest" },
     { name = "pytest-asyncio" },
@@ -312,13 +315,14 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "falkordb-bin", marker = "extra == 'lite'", specifier = ">=1.4.0,<2.0.0" },
     { name = "pytest", marker = "extra == 'test'", specifier = ">=9.0.2" },
     { name = "pytest-asyncio", marker = "extra == 'test'", specifier = ">=1.3.0" },
     { name = "pytest-cov", marker = "extra == 'test'", specifier = ">=7.0.0" },
     { name = "python-dateutil", specifier = ">=2.9.0" },
     { name = "redis", specifier = ">=7.1.0" },
 ]
-provides-extras = ["test"]
+provides-extras = ["lite", "test"]
 
 [package.metadata.requires-dev]
 dev = [
@@ -327,6 +331,25 @@ dev = [
     { name = "types-redis", specifier = ">=4.6.0" },
 ]
 
+[[package]]
+name = "falkordb-bin"
+version = "1.4.1"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/0d/d126b80e55e00b93c8af8263c8eed9d13afceed7a75991e9d38323e36f7a/falkordb_bin-1.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:bbcc8d3fd34bc6bc0b5abcbfbcd54be5aaded066800cc92d2c2c865a67002006", size = 10583725, upload-time = "2026-02-14T15:57:49.049Z" },
+    { url = "https://files.pythonhosted.org/packages/16/b5/ef7cc56b30b8b509e0210b78e5ff58313109a4c4352c411a3844a2a81f65/falkordb_bin-1.4.1-cp310-cp310-manylinux_2_17_aarch64.whl", hash = "sha256:d88327eb75970a7d11c37bb4ce19fcf1e4fcefd47b4589ce452f213418023d5f", size = 20911174, upload-time = "2026-02-14T15:57:50.972Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/e0/741beecc1b2cd9ecf3782be763a09480cd92c127b00dadb34f91832119c8/falkordb_bin-1.4.1-cp310-cp310-manylinux_2_17_x86_64.whl", hash = "sha256:10c702f9878153745928c9c68e65b8fbf5f4124dadc52d80d1118a9b453c1319", size = 22001846, upload-time = "2026-02-14T15:57:52.889Z" },
+    { url = "https://files.pythonhosted.org/packages/41/28/3786e5fb2fb7ec616aee6f01f30c0a1e9e49d0fea8427a5012d974ab12ca/falkordb_bin-1.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ec8ff270b694c902e385247bab1737a3085b29c7cd3af799fcd8dfe6b454bb1", size = 10583725, upload-time = "2026-02-14T15:57:54.767Z" },
+    { url = "https://files.pythonhosted.org/packages/59/cd/c4ece6c0ed47e45e769899417a421158967ab9cef0edafcd5ed7b0746984/falkordb_bin-1.4.1-cp311-cp311-manylinux_2_17_aarch64.whl", hash = "sha256:ac50404edc37d9b284bae144dbce6ec8421c6962fb89f912d6a0b8c56a61916e", size = 20911174, upload-time = "2026-02-14T15:57:56.377Z" },
+    { url = "https://files.pythonhosted.org/packages/26/65/2f1e5824148f10b2be42192e0e8b3f0c82ea9d51efa51d97ce0c060bfb57/falkordb_bin-1.4.1-cp311-cp311-manylinux_2_17_x86_64.whl", hash = "sha256:e52b29313542cf18e0463b1130c1f517ff7b594638ee2fe6eea2b6f8ccfd4b9d", size = 22001847, upload-time = "2026-02-14T15:57:58.307Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/7e/8ecdfc535b51e5cbcda9fc28083e91ab17469f032c5c4a3317d44b805345/falkordb_bin-1.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1eccc0425977adb53cec19cf0e54b8193c167f255e2eaadbd431a73b7073a2c4", size = 10583724, upload-time = "2026-02-14T15:58:00.398Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/25/7424d5c4df388420af54bc3c51e1e356327b2d41da037a43868f3bb45c98/falkordb_bin-1.4.1-cp312-cp312-manylinux_2_17_aarch64.whl", hash = "sha256:afde9b65a12c42412bd61998e98fcb522198b0235cf7f19ed4dea28449cc36a6", size = 20911174, upload-time = "2026-02-14T15:58:02.362Z" },
+    { url = "https://files.pythonhosted.org/packages/94/05/497d9ac5f9ba8508cae8074538864e537a98f6ac0baa95340ffda73d4952/falkordb_bin-1.4.1-cp312-cp312-manylinux_2_17_x86_64.whl", hash = "sha256:b192f03d1bb63f5d5652c1f310d9adb2a01a40866d3cd9a2c267e8f5bdc51dc8", size = 22001846, upload-time = "2026-02-14T15:58:04.682Z" },
+    { url = "https://files.pythonhosted.org/packages/91/d7/71243f104105e948e3baa87bd66f239f272d3ca4d2636636c8d7c24ddd18/falkordb_bin-1.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a1ce349fcc868bec8144ce9d63e1ff00bd5b6f45a383c7774f1d9e3417aad537", size = 10583726, upload-time = "2026-02-14T15:58:07.95Z" },
+    { url = "https://files.pythonhosted.org/packages/52/b0/b59fb21b1ba0afc727c66f9127d557cabce89885f18ad61817d59f00c567/falkordb_bin-1.4.1-cp313-cp313-manylinux_2_17_aarch64.whl", hash = "sha256:520ff46ddb214177d71433414cd60cfb2e8130d56f26a45895088ba68f144a54", size = 20911175, upload-time = "2026-02-14T15:58:10.154Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/90/61352691ecade84ec271f1f4571932092006f1d3748cfcb74ddbdb89b1a6/falkordb_bin-1.4.1-cp313-cp313-manylinux_2_17_x86_64.whl", hash = "sha256:f360edd128f4e9d7438ec18ee4012ca9ba799778b3c928d68bfd8f47f85dc406", size = 22001848, upload-time = "2026-02-14T15:58:12.929Z" },
+]
+
 [[package]]
 name = "iniconfig"
 version = "2.3.0"