diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0da388c..a18f689 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.0] - 2026-05-01
+
+### Added
+- **Generic type parsing** - Full support for generic type annotations in Python code
+  - Parse `list[T]`, `dict[K, V]`, `set[T]`, `tuple[T, ...]` generic types
+  - Parse union types: `X | None`, `int | str | None`
+  - Parse `Optional[T]` from typing module
+  - Parse nested generics: `list[dict[str, int]]`, `dict[str, list[int]]`
+  - Support typing module aliases: `List[int]`, `Dict[str, Any]`
+  - **User Outcome**: Eliminates false positive warnings from type inference
+  - Created `type_utils.parse_type_annotation()` helper for consistent type parsing
+  - Updated `ASTExtractor._get_type_string()` to use helper
+  - Updated `TypeInferrer._get_type_string()` to use helper
+  - All 312 unit tests passing (20 new tests added)
+
+### Changed
+- Type annotations now preserve full generic information instead of erasing to base type
+  - Before: `list[int]` → stored as "list"
+  - After: `list[int]` → stored as "list[int]"
+- Type inference validation now correctly compares generic types
+
 ## [0.8.4] - 2026-05-01
 
 ### Added
diff --git a/CLAUDE.md b/CLAUDE.md
index d699a66..3bcb13e 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -423,4 +423,4 @@ Review these documents to understand patterns and best practices:
 ---
 
 **Last Updated**: 2026-05-01  
-**Current Version**: 0.8.4
+**Current Version**: 0.9.0
diff --git a/README.md b/README.md
index b837a20..faafe88 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Mapper (Application Mapper)
 
-![Version](https://img.shields.io/badge/version-0.8.4-blue.svg)
+![Version](https://img.shields.io/badge/version-0.9.0-blue.svg)
 ![Tests](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/ydkadri/9501806ed5eac873dd324bc606c6dd79/raw/mapper-tests.json&cacheSeconds=300)
 ![Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/ydkadri/9501806ed5eac873dd324bc606c6dd79/raw/mapper-coverage.json&cacheSeconds=300)
 ![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)
diff --git a/pyproject.toml b/pyproject.toml
index 47512bc..a366e1a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mapper"
-version = "0.8.4"
+version = "0.9.0"
 description = "Mapper (Application Mapper) - AST-based Python code analyzer with Neo4j graph storage"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -93,7 +93,7 @@ addopts = [
 testpaths = ["tests"]
 
 [tool.bumpversion]
-current_version = "0.8.4"
+current_version = "0.9.0"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"
diff --git a/src/mapper/__init__.py b/src/mapper/__init__.py
index 7fac3f3..527778d 100644
--- a/src/mapper/__init__.py
+++ b/src/mapper/__init__.py
@@ -3,7 +3,7 @@
 # Public modules for programmatic access
 from mapper import analyser, graph, graph_loader
 
-__version__ = "0.8.4"
+__version__ = "0.9.0"
 
 __all__ = [
     # Version
diff --git a/src/mapper/ast_parser/extractor.py b/src/mapper/ast_parser/extractor.py
index 6139095..c26620c 100644
--- a/src/mapper/ast_parser/extractor.py
+++ b/src/mapper/ast_parser/extractor.py
@@ -5,6 +5,7 @@
 
 from mapper import name_resolver
 from mapper.ast_parser import models
+from mapper.type_inference import type_utils
 
 
 class ASTExtractor:
@@ -421,17 +422,16 @@ def _extract_call(self, node: ast.Call) -> models.CallInfo | None:
     def _get_type_string(self, node: ast.expr) -> str:
         """Convert type annotation node to string.
 
+        Supports simple types, generic types (list[int], dict[str, Any]),
+        union types (str | None), and Optional types.
+
         Args:
             node: AST type annotation node
 
         Returns:
             Type as string
         """
-        if isinstance(node, ast.Name):
-            return node.id
-        elif isinstance(node, ast.Constant):
-            return str(node.value)
-        return "Unknown"
+        return type_utils.parse_type_annotation(node)
 
     def _get_attribute_string(self, node: ast.Attribute) -> str:
         """Convert attribute node to string.
diff --git a/src/mapper/type_inference/inferrer.py b/src/mapper/type_inference/inferrer.py
index 5b10aaa..538b91a 100644
--- a/src/mapper/type_inference/inferrer.py
+++ b/src/mapper/type_inference/inferrer.py
@@ -3,7 +3,7 @@
 import ast
 
 from mapper import ast_parser
-from mapper.type_inference import models
+from mapper.type_inference import models, type_utils
 
 
 class TypeInferrer:
@@ -177,14 +177,13 @@ def _infer_from_expression(self, node: ast.expr) -> str | None:
     def _get_type_string(self, node: ast.expr) -> str:
         """Convert type annotation node to string.
 
+        Supports simple types, generic types (list[int], dict[str, Any]),
+        union types (str | None), and Optional types.
+
         Args:
             node: AST type annotation node
 
         Returns:
             Type as string
         """
-        if isinstance(node, ast.Name):
-            return node.id
-        elif isinstance(node, ast.Constant):
-            return str(node.value)
-        return "Unknown"
+        return type_utils.parse_type_annotation(node)
diff --git a/src/mapper/type_inference/type_utils.py b/src/mapper/type_inference/type_utils.py
new file mode 100644
index 0000000..d846ea8
--- /dev/null
+++ b/src/mapper/type_inference/type_utils.py
@@ -0,0 +1,60 @@
+"""Utilities for parsing and handling type annotations."""
+
+import ast
+
+
+def parse_type_annotation(node: ast.expr) -> str:
+    """Parse a type annotation AST node into a string representation.
+
+    Handles:
+    - Simple types: str, int, CustomClass
+    - Generic types: list[int], dict[str, Any]
+    - Union types: str | None, int | str
+    - Optional types: Optional[str]
+
+    Args:
+        node: AST expression node representing a type annotation
+
+    Returns:
+        String representation of the type
+
+    Examples:
+        >>> # ast.Name(id='str') -> 'str'
+        >>> # ast.Subscript(value=Name('list'), slice=Name('int')) -> 'list[int]'
+        >>> # ast.BinOp(left=Name('str'), op=BitOr(), right=Name('None')) -> 'str | None'
+    """
+    # Simple name: str, int, CustomClass
+    if isinstance(node, ast.Name):
+        return node.id
+
+    # Subscripted generic: list[T], dict[K, V], Optional[T]
+    elif isinstance(node, ast.Subscript):
+        base = parse_type_annotation(node.value)
+
+        # Handle single subscript: list[int], Optional[str]
+        if isinstance(node.slice, ast.Name):
+            arg = node.slice.id
+            return f"{base}[{arg}]"
+
+        # Handle multiple subscripts: dict[str, int]
+        elif isinstance(node.slice, ast.Tuple):
+            args = [parse_type_annotation(elt) for elt in node.slice.elts]
+            return f"{base}[{', '.join(args)}]"
+
+        # Recursively handle complex subscripts
+        else:
+            arg = parse_type_annotation(node.slice)
+            return f"{base}[{arg}]"
+
+    # Union type with | operator: str | None, int | str | None
+    elif isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitOr):
+        left = parse_type_annotation(node.left)
+        right = parse_type_annotation(node.right)
+        return f"{left} | {right}"
+
+    # Constant (edge case - might appear in some type contexts)
+    elif isinstance(node, ast.Constant):
+        return str(node.value)
+
+    # Unknown or unsupported type annotation
+    return "Unknown"
diff --git a/tests/unit/ast_parser/test_extractor.py b/tests/unit/ast_parser/test_extractor.py
index ccc0150..daee7f0 100644
--- a/tests/unit/ast_parser/test_extractor.py
+++ b/tests/unit/ast_parser/test_extractor.py
@@ -218,6 +218,44 @@ def returns_user() -> User:
         func = result.functions[0]
         assert func.return_type == "User"
 
+    def test_extract_generic_type_annotations(self):
+        """Test extracting generic type annotations (list, dict, Optional, union)."""
+        code = textwrap.dedent("""
+            def process_list(items: list[str]) -> list[int]:
+                return [1, 2, 3]
+
+            def process_dict(data: dict[str, Any]) -> dict[str, int]:
+                return {"count": 5}
+
+            def optional_result() -> str | None:
+                return None
+
+            def optional_param(value: Optional[int]) -> int:
+                return value or 0
+        """)
+
+        extractor = ast_parser.ASTExtractor(code, "module.py")
+        result = extractor.extract()
+
+        # Test list[str] -> list[int]
+        process_list = next(f for f in result.functions if f.name == "process_list")
+        assert process_list.parameters[0].type_hint == "list[str]"
+        assert process_list.return_type == "list[int]"
+
+        # Test dict[str, Any] -> dict[str, int]
+        process_dict = next(f for f in result.functions if f.name == "process_dict")
+        assert process_dict.parameters[0].type_hint == "dict[str, Any]"
+        assert process_dict.return_type == "dict[str, int]"
+
+        # Test union type: str | None
+        optional_result = next(f for f in result.functions if f.name == "optional_result")
+        assert optional_result.return_type == "str | None"
+
+        # Test Optional[int]
+        optional_param = next(f for f in result.functions if f.name == "optional_param")
+        assert optional_param.parameters[0].type_hint == "Optional[int]"
+        assert optional_param.return_type == "int"
+
     def test_extract_invalid_syntax(self):
         """Test extracting from code with syntax errors."""
         code = "def invalid syntax here"
diff --git a/tests/unit/type_inference/test_inference.py b/tests/unit/type_inference/test_inference.py
index 27e2b11..44b93fa 100644
--- a/tests/unit/type_inference/test_inference.py
+++ b/tests/unit/type_inference/test_inference.py
@@ -170,3 +170,35 @@ def no_return():
         # Functions with no return statement implicitly return None
         assert result.inferred_type == "None"
         assert result.confidence == "high"
+
+    def test_infer_with_generic_type_annotations(self):
+        """Test that generic type annotations are properly extracted and used."""
+        code = textwrap.dedent(
+            """
+            def process_list() -> list[int]:
+                return [1, 2, 3]
+
+            def process_dict() -> dict[str, Any]:
+                return {"key": "value"}
+
+            def optional_result() -> str | None:
+                if True:
+                    return "result"
+                return None
+        """
+        )
+
+        inferrer = self._create_inferrer(code)
+
+        # Test that generic type annotations are properly extracted
+        list_result = inferrer.infer_function_return("process_list")
+        assert list_result.inferred_type == "list[int]"
+        assert list_result.confidence == "high"
+
+        dict_result = inferrer.infer_function_return("process_dict")
+        assert dict_result.inferred_type == "dict[str, Any]"
+        assert dict_result.confidence == "high"
+
+        optional_result = inferrer.infer_function_return("optional_result")
+        assert optional_result.inferred_type == "str | None"
+        assert optional_result.confidence == "high"
diff --git a/tests/unit/type_inference/test_type_utils.py b/tests/unit/type_inference/test_type_utils.py
new file mode 100644
index 0000000..e301402
--- /dev/null
+++ b/tests/unit/type_inference/test_type_utils.py
@@ -0,0 +1,221 @@
+"""Tests for type annotation parsing utilities."""
+
+import ast
+import textwrap
+
+from mapper.type_inference import type_utils
+
+
+class TestParseTypeAnnotation:
+    """Tests for parse_type_annotation function."""
+
+    def test_simple_builtin_types(self):
+        """Test parsing simple built-in type names."""
+        # str
+        code = "x: str"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "str"
+
+        # int
+        code = "x: int"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "int"
+
+        # bool
+        code = "x: bool"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "bool"
+
+    def test_custom_class_types(self):
+        """Test parsing custom class names."""
+        code = "x: CustomClass"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "CustomClass"
+
+    def test_list_with_single_type(self):
+        """Test parsing list[T] generic types."""
+        # list[int]
+        code = "x: list[int]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "list[int]"
+
+        # list[str]
+        code = "x: list[str]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "list[str]"
+
+        # list[CustomClass]
+        code = "x: list[CustomClass]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "list[CustomClass]"
+
+    def test_dict_with_two_types(self):
+        """Test parsing dict[K, V] generic types."""
+        # dict[str, int]
+        code = "x: dict[str, int]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "dict[str, int]"
+
+        # dict[str, Any]
+        code = "x: dict[str, Any]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "dict[str, Any]"
+
+        # dict[int, CustomClass]
+        code = "x: dict[int, CustomClass]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "dict[int, CustomClass]"
+
+    def test_optional_type(self):
+        """Test parsing Optional[T] types."""
+        # Optional[str]
+        code = "x: Optional[str]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "Optional[str]"
+
+        # Optional[int]
+        code = "x: Optional[int]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "Optional[int]"
+
+        # Optional[CustomClass]
+        code = "x: Optional[CustomClass]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "Optional[CustomClass]"
+
+    def test_union_type_with_none(self):
+        """Test parsing X | None union types."""
+        # str | None
+        code = "x: str | None"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "str | None"
+
+        # int | None
+        code = "x: int | None"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "int | None"
+
+        # CustomClass | None
+        code = "x: CustomClass | None"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "CustomClass | None"
+
+    def test_union_type_multiple(self):
+        """Test parsing multi-type unions."""
+        # int | str
+        code = "x: int | str"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "int | str"
+
+        # int | str | None (chained unions parse left-to-right)
+        code = "x: int | str | None"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        # Union is left-associative: (int | str) | None
+        result = type_utils.parse_type_annotation(ann_node)
+        assert result == "int | str | None"
+
+    def test_set_type(self):
+        """Test parsing set[T] generic types."""
+        code = "x: set[int]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "set[int]"
+
+    def test_tuple_type(self):
+        """Test parsing tuple[T, ...] generic types."""
+        # tuple[int, str]
+        code = "x: tuple[int, str]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "tuple[int, str]"
+
+    def test_nested_generic_list_of_dicts(self):
+        """Test parsing nested generics like list[dict[str, int]]."""
+        code = "x: list[dict[str, int]]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "list[dict[str, int]]"
+
+    def test_nested_generic_dict_of_lists(self):
+        """Test parsing nested generics like dict[str, list[int]]."""
+        code = "x: dict[str, list[int]]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "dict[str, list[int]]"
+
+    def test_union_of_generics(self):
+        """Test parsing unions of generic types."""
+        code = "x: list[int] | None"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "list[int] | None"
+
+    def test_typing_module_List(self):
+        """Test parsing typing.List (capital L) which is ast.Name."""
+        # Note: List[int] from typing module is parsed as:
+        # Subscript(value=Name('List'), slice=Name('int'))
+        # Our function handles this the same as list[int]
+        code = "x: List[int]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "List[int]"
+
+    def test_typing_module_Dict(self):
+        """Test parsing typing.Dict (capital D)."""
+        code = "x: Dict[str, int]"
+        tree = ast.parse(code)
+        ann_node = tree.body[0].annotation
+        assert type_utils.parse_type_annotation(ann_node) == "Dict[str, int]"
+
+    def test_constant_annotation(self):
+        """Test parsing constant annotations (edge case)."""
+        # This is an edge case - constants can appear in some type contexts
+        # Our function should handle it gracefully
+        node = ast.Constant(value="SomeType")
+        assert type_utils.parse_type_annotation(node) == "SomeType"
+
+    def test_unknown_node_type(self):
+        """Test that unknown AST nodes return 'Unknown'."""
+        # Pass an unsupported AST node type
+        node = ast.Pass()  # Not a valid type annotation node
+        assert type_utils.parse_type_annotation(node) == "Unknown"
+
+    def test_function_return_type_annotation(self):
+        """Test parsing return type from function definition."""
+        code = textwrap.dedent("""
+            def process_data() -> dict[str, list[int]]:
+                pass
+        """)
+        tree = ast.parse(code)
+        func_node = tree.body[0]
+        return_annotation = func_node.returns
+        assert type_utils.parse_type_annotation(return_annotation) == "dict[str, list[int]]"
+
+    def test_parameter_type_annotation(self):
+        """Test parsing parameter type annotation."""
+        code = textwrap.dedent("""
+            def process(data: list[str]) -> None:
+                pass
+        """)
+        tree = ast.parse(code)
+        func_node = tree.body[0]
+        param_annotation = func_node.args.args[0].annotation
+        assert type_utils.parse_type_annotation(param_annotation) == "list[str]"