diff --git a/.gitignore b/.gitignore
index 4fb5c14..f52e12c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 testdata/sandbox
 cmd/termmapper
+examples/
 README.md
\ No newline at end of file
diff --git a/pkg/mapper/mapper.go b/pkg/mapper/mapper.go
new file mode 100644
index 0000000..f540525
--- /dev/null
+++ b/pkg/mapper/mapper.go
@@ -0,0 +1,185 @@
+package mapper
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"github.com/KorAP/KoralPipe-TermMapper2/pkg/ast"
+	"github.com/KorAP/KoralPipe-TermMapper2/pkg/config"
+	"github.com/KorAP/KoralPipe-TermMapper2/pkg/matcher"
+	"github.com/KorAP/KoralPipe-TermMapper2/pkg/parser"
+)
+
+// Direction represents the mapping direction (A to B or B to A)
+type Direction string
+
+const (
+	AtoB Direction = "atob"
+	BtoA Direction = "btoa"
+)
+
+// Mapper handles the application of mapping rules to JSON objects
+type Mapper struct {
+	mappingLists map[string]*config.MappingList
+	parsedRules  map[string][]*parser.MappingResult
+}
+
+// NewMapper creates a new Mapper instance
+func NewMapper(configFiles ...string) (*Mapper, error) {
+	m := &Mapper{
+		mappingLists: make(map[string]*config.MappingList),
+		parsedRules:  make(map[string][]*parser.MappingResult),
+	}
+
+	// Load and parse all config files
+	for _, file := range configFiles {
+		cfg, err := config.LoadConfig(file)
+		if err != nil {
+			return nil, fmt.Errorf("failed to load config from %s: %w", file, err)
+		}
+
+		// Store mapping lists by ID
+		for _, list := range cfg.Lists {
+			if _, exists := m.mappingLists[list.ID]; exists {
+				return nil, fmt.Errorf("duplicate mapping list ID found: %s", list.ID)
+			}
+
+			// Create a copy of the list to store
+			listCopy := list
+			m.mappingLists[list.ID] = &listCopy
+
+			// Parse the rules immediately
+			parsedRules, err := list.ParseMappings()
+			if err != nil {
+				return nil, fmt.Errorf("failed to parse mappings for list %s: %w", list.ID, err)
+			}
+			m.parsedRules[list.ID] = parsedRules
+		}
+	}
+
+	return m, nil
+}
+
+// MappingOptions contains the options for applying mappings
+type MappingOptions struct {
+	FoundryA  string
+	LayerA    string
+	FoundryB  string
+	LayerB    string
+	Direction Direction
+}
+
+// ApplyMappings applies the specified mapping rules to a JSON object
+func (m *Mapper) ApplyMappings(mappingID string, opts MappingOptions, jsonData interface{}) (interface{}, error) {
+	// Validate mapping ID
+	if _, exists := m.mappingLists[mappingID]; !exists {
+		return nil, fmt.Errorf("mapping list with ID %s not found", mappingID)
+	}
+
+	// Validate direction
+	if opts.Direction != AtoB && opts.Direction != BtoA {
+		return nil, fmt.Errorf("invalid direction: %s", opts.Direction)
+	}
+
+	// Get the parsed rules
+	rules := m.parsedRules[mappingID]
+
+	// Convert input JSON to AST
+	jsonBytes, err := json.Marshal(jsonData)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal input JSON: %w", err)
+	}
+
+	node, err := parser.ParseJSON(jsonBytes)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse JSON into AST: %w", err)
+	}
+
+	// Extract the inner node if it's a token
+	if token, ok := node.(*ast.Token); ok {
+		node = token.Wrap
+	}
+
+	// Apply each rule to the AST
+	for _, rule := range rules {
+		// Create pattern and replacement based on direction
+		var pattern, replacement ast.Node
+		if opts.Direction == AtoB {
+			pattern = rule.Upper
+			replacement = rule.Lower
+		} else {
+			pattern = rule.Lower
+			replacement = rule.Upper
+		}
+
+		// Extract the inner nodes from the pattern and replacement tokens
+		if token, ok := pattern.(*ast.Token); ok {
+			pattern = token.Wrap
+		}
+		if token, ok := replacement.(*ast.Token); ok {
+			replacement = token.Wrap
+		}
+
+		// Apply foundry and layer overrides
+		if opts.Direction == AtoB {
+			applyFoundryAndLayerOverrides(pattern, opts.FoundryA, opts.LayerA)
+			applyFoundryAndLayerOverrides(replacement, opts.FoundryB, opts.LayerB)
+		} else {
+			applyFoundryAndLayerOverrides(pattern, opts.FoundryB, opts.LayerB)
+			applyFoundryAndLayerOverrides(replacement, opts.FoundryA, opts.LayerA)
+		}
+
+		// Create matcher and apply replacement
+		m := matcher.NewMatcher(ast.Pattern{Root: pattern}, ast.Replacement{Root: replacement})
+		node = m.Replace(node)
+	}
+
+	// Wrap the result in a token
+	result := &ast.Token{Wrap: node}
+
+	// Convert AST back to JSON
+	resultBytes, err := parser.SerializeToJSON(result)
+	if err != nil {
+		return nil, fmt.Errorf("failed to serialize AST to JSON: %w", err)
+	}
+
+	// Parse the JSON string back into an interface{}
+	var resultData interface{}
+	if err := json.Unmarshal(resultBytes, &resultData); err != nil {
+		return nil, fmt.Errorf("failed to parse result JSON: %w", err)
+	}
+
+	return resultData, nil
+}
+
+// applyFoundryAndLayerOverrides recursively applies foundry and layer overrides to terms
+func applyFoundryAndLayerOverrides(node ast.Node, foundry, layer string) {
+	if node == nil {
+		return
+	}
+
+	switch n := node.(type) {
+	case *ast.Term:
+		if foundry != "" {
+			n.Foundry = foundry
+		}
+		if layer != "" {
+			n.Layer = layer
+		}
+	case *ast.TermGroup:
+		for _, op := range n.Operands {
+			applyFoundryAndLayerOverrides(op, foundry, layer)
+		}
+	case *ast.Token:
+		if n.Wrap != nil {
+			applyFoundryAndLayerOverrides(n.Wrap, foundry, layer)
+		}
+	case *ast.CatchallNode:
+		if n.Wrap != nil {
+			applyFoundryAndLayerOverrides(n.Wrap, foundry, layer)
+		}
+		for _, op := range n.Operands {
+			applyFoundryAndLayerOverrides(op, foundry, layer)
+		}
+	}
+}
diff --git a/pkg/mapper/mapper_test.go b/pkg/mapper/mapper_test.go
new file mode 100644
index 0000000..b5a8950
--- /dev/null
+++ b/pkg/mapper/mapper_test.go
@@ -0,0 +1,228 @@
+package mapper
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMapper(t *testing.T) {
+	// Create a temporary config file
+	tmpDir := t.TempDir()
+	configFile := filepath.Join(tmpDir, "test-config.yaml")
+
+	configContent := `- id: test-mapper
+  foundryA: opennlp
+  layerA: p
+  foundryB: upos
+  layerB: p
+  mappings:
+    - "[PIDAT] <> [opennlp/p=PIDAT & opennlp/p=AdjType:Pdt]"
+    - "[DET] <> [opennlp/p=DET]"`
+
+	err := os.WriteFile(configFile, []byte(configContent), 0644)
+	require.NoError(t, err)
+
+	// Create a new mapper
+	m, err := NewMapper(configFile)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name        string
+		mappingID   string
+		opts        MappingOptions
+		input       string
+		expected    string
+		expectError bool
+	}{
+		{
+			name:      "Simple A to B mapping",
+			mappingID: "test-mapper",
+			opts: MappingOptions{
+				Direction: AtoB,
+			},
+			input: `{
+				"@type": "koral:token",
+				"wrap": {
+					"@type": "koral:term",
+					"foundry": "opennlp",
+					"key": "PIDAT",
+					"layer": "p",
+					"match": "match:eq"
+				}
+			}`,
+			expected: `{
+				"@type": "koral:token",
+				"wrap": {
+					"@type": "koral:termGroup",
+					"operands": [
+						{
+							"@type": "koral:term",
+							"foundry": "opennlp",
+							"key": "PIDAT",
+							"layer": "p",
+							"match": "match:eq"
+						},
+						{
+							"@type": "koral:term",
+							"foundry": "opennlp",
+							"key": "AdjType",
+							"layer": "p",
+							"match": "match:eq",
+							"value": "Pdt"
+						}
+					],
+					"relation": "relation:and"
+				}
+			}`,
+		},
+		{
+			name:      "B to A mapping",
+			mappingID: "test-mapper",
+			opts: MappingOptions{
+				Direction: BtoA,
+			},
+			input: `{
+				"@type": "koral:token",
+				"wrap": {
+					"@type": "koral:termGroup",
+					"operands": [
+						{
+							"@type": "koral:term",
+							"foundry": "opennlp",
+							"key": "PIDAT",
+							"layer": "p",
+							"match": "match:eq"
+						},
+						{
+							"@type": "koral:term",
+							"foundry": "opennlp",
+							"key": "AdjType",
+							"layer": "p",
+							"match": "match:eq",
+							"value": "Pdt"
+						}
+					],
+					"relation": "relation:and"
+				}
+			}`,
+			expected: `{
+				"@type": "koral:token",
+				"wrap": {
+					"@type": "koral:term",
+					"foundry": "opennlp",
+					"key": "PIDAT",
+					"layer": "p",
+					"match": "match:eq"
+				}
+			}`,
+		},
+		{
+			name:      "Mapping with foundry override",
+			mappingID: "test-mapper",
+			opts: MappingOptions{
+				Direction: AtoB,
+				FoundryB:  "custom",
+			},
+			input: `{
+				"@type": "koral:token",
+				"wrap": {
+					"@type": "koral:term",
+					"foundry": "opennlp",
+					"key": "PIDAT",
+					"layer": "p",
+					"match": "match:eq"
+				}
+			}`,
+			expected: `{
+				"@type": "koral:token",
+				"wrap": {
+					"@type": "koral:termGroup",
+					"operands": [
+						{
+							"@type": "koral:term",
+							"foundry": "custom",
+							"key": "PIDAT",
+							"layer": "p",
+							"match": "match:eq"
+						},
+						{
+							"@type": "koral:term",
+							"foundry": "custom",
+							"key": "AdjType",
+							"layer": "p",
+							"match": "match:eq",
+							"value": "Pdt"
+						}
+					],
+					"relation": "relation:and"
+				}
+			}`,
+		},
+		{
+			name:      "Invalid mapping ID",
+			mappingID: "nonexistent",
+			opts: MappingOptions{
+				Direction: AtoB,
+			},
+			input: `{
+				"@type": "koral:token",
+				"wrap": {
+					"@type": "koral:term",
+					"foundry": "opennlp",
+					"key": "PIDAT",
+					"layer": "p",
+					"match": "match:eq"
+				}
+			}`,
+			expectError: true,
+		},
+		{
+			name:      "Invalid direction",
+			mappingID: "test-mapper",
+			opts: MappingOptions{
+				Direction: "invalid",
+			},
+			input: `{
+				"@type": "koral:token",
+				"wrap": {
+					"@type": "koral:term",
+					"foundry": "opennlp",
+					"key": "PIDAT",
+					"layer": "p",
+					"match": "match:eq"
+				}
+			}`,
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Parse input JSON
+			var inputData interface{}
+			err := json.Unmarshal([]byte(tt.input), &inputData)
+			require.NoError(t, err)
+
+			// Apply mappings
+			result, err := m.ApplyMappings(tt.mappingID, tt.opts, inputData)
+			if tt.expectError {
+				assert.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+
+			// Parse expected JSON
+			var expectedData interface{}
+			err = json.Unmarshal([]byte(tt.expected), &expectedData)
+			require.NoError(t, err)
+
+			// Compare results
+			assert.Equal(t, expectedData, result)
+		})
+	}
+}