diff --git a/parser/parser.go b/parser/parser.go
new file mode 100644
index 0000000..d81c3b0
--- /dev/null
+++ b/parser/parser.go
@@ -0,0 +1,346 @@
+package parser
+
+// parser is a function that takes a JSON string and returns an AST node.
+// It is used to parse a JSON string into an AST node.
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/KorAP/KoralPipe-TermMapper2/ast"
+)
+
+// rawNode represents the raw JSON structure
+type rawNode struct {
+	Type     string          `json:"@type"`
+	Wrap     json.RawMessage `json:"wrap,omitempty"`
+	Operands []rawNode       `json:"operands,omitempty"`
+	Relation string          `json:"relation,omitempty"`
+	Foundry  string          `json:"foundry,omitempty"`
+	Key      string          `json:"key,omitempty"`
+	Layer    string          `json:"layer,omitempty"`
+	Match    string          `json:"match,omitempty"`
+	Value    string          `json:"value,omitempty"`
+	// Store any additional fields
+	Extra map[string]interface{} `json:"-"`
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface
+func (r *rawNode) UnmarshalJSON(data []byte) error {
+	// First unmarshal into a map to capture all fields
+	var raw map[string]interface{}
+	if err := json.Unmarshal(data, &raw); err != nil {
+		return err
+	}
+
+	// Create a temporary struct to unmarshal known fields
+	type tempNode rawNode
+	var temp tempNode
+	if err := json.Unmarshal(data, &temp); err != nil {
+		return err
+	}
+	*r = rawNode(temp)
+
+	// Store any fields not in the struct in Extra
+	r.Extra = make(map[string]interface{})
+	for k, v := range raw {
+		switch k {
+		case "@type", "wrap", "operands", "relation", "foundry", "key", "layer", "match", "value":
+			continue
+		default:
+			r.Extra[k] = v
+		}
+	}
+
+	return nil
+}
+
+// MarshalJSON implements the json.Marshaler interface
+func (r rawNode) MarshalJSON() ([]byte, error) {
+	// Create a map with all fields
+	raw := make(map[string]interface{})
+
+	// Add the known fields if they're not empty
+	raw["@type"] = r.Type
+	if r.Wrap != nil {
+		raw["wrap"] = r.Wrap
+	}
+	if len(r.Operands) > 0 {
+		raw["operands"] = r.Operands
+	}
+	if r.Relation != "" {
+		raw["relation"] = r.Relation
+	}
+	if r.Foundry != "" {
+		raw["foundry"] = r.Foundry
+	}
+	if r.Key != "" {
+		raw["key"] = r.Key
+	}
+	if r.Layer != "" {
+		raw["layer"] = r.Layer
+	}
+	if r.Match != "" {
+		raw["match"] = r.Match
+	}
+	if r.Value != "" {
+		raw["value"] = r.Value
+	}
+
+	// Add any extra fields
+	for k, v := range r.Extra {
+		raw[k] = v
+	}
+
+	return json.Marshal(raw)
+}
+
+// ParseJSON parses a JSON string into our AST representation
+func ParseJSON(data []byte) (ast.Node, error) {
+	var raw rawNode
+	if err := json.Unmarshal(data, &raw); err != nil {
+		return nil, fmt.Errorf("failed to parse JSON: %w", err)
+	}
+	if raw.Type == "" {
+		return nil, fmt.Errorf("missing required field '@type' in JSON")
+	}
+	return parseNode(raw)
+}
+
+// parseNode converts a raw node into an AST node
+func parseNode(raw rawNode) (ast.Node, error) {
+	switch raw.Type {
+	case "koral:token":
+		if raw.Wrap == nil {
+			return nil, fmt.Errorf("token node of type '%s' missing required 'wrap' field", raw.Type)
+		}
+		var wrapRaw rawNode
+		if err := json.Unmarshal(raw.Wrap, &wrapRaw); err != nil {
+			return nil, fmt.Errorf("failed to parse 'wrap' field in token node: %w", err)
+		}
+		wrap, err := parseNode(wrapRaw)
+		if err != nil {
+			return nil, fmt.Errorf("error parsing wrapped node: %w", err)
+		}
+		return &ast.Token{Wrap: wrap}, nil
+
+	case "koral:termGroup":
+		if len(raw.Operands) == 0 {
+			return nil, fmt.Errorf("term group must have at least one operand")
+		}
+
+		operands := make([]ast.Node, len(raw.Operands))
+		for i, op := range raw.Operands {
+			node, err := parseNode(op)
+			if err != nil {
+				return nil, fmt.Errorf("error parsing operand %d: %w", i+1, err)
+			}
+			operands[i] = node
+		}
+
+		if raw.Relation == "" {
+			return nil, fmt.Errorf("term group must have a 'relation' field")
+		}
+
+		relation := ast.AndRelation
+		if strings.HasSuffix(raw.Relation, "or") {
+			relation = ast.OrRelation
+		} else if !strings.HasSuffix(raw.Relation, "and") {
+			return nil, fmt.Errorf("invalid relation type '%s', must be one of: 'relation:and', 'relation:or'", raw.Relation)
+		}
+
+		return &ast.TermGroup{
+			Operands: operands,
+			Relation: relation,
+		}, nil
+
+	case "koral:term":
+		if raw.Key == "" {
+			return nil, fmt.Errorf("term must have a 'key' field")
+		}
+
+		match := ast.MatchEqual
+		if raw.Match != "" {
+			if strings.HasSuffix(raw.Match, "ne") {
+				match = ast.MatchNotEqual
+			} else if !strings.HasSuffix(raw.Match, "eq") {
+				return nil, fmt.Errorf("invalid match type '%s', must be one of: 'match:eq', 'match:ne'", raw.Match)
+			}
+		}
+
+		return &ast.Term{
+			Foundry: raw.Foundry,
+			Key:     raw.Key,
+			Layer:   raw.Layer,
+			Match:   match,
+			Value:   raw.Value,
+		}, nil
+
+	default:
+		// Store the original JSON content
+		rawContent, err := json.Marshal(raw)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal unknown node type '%s': %w", raw.Type, err)
+		}
+
+		// Create a catchall node
+		catchall := &ast.CatchallNode{
+			NodeType:   raw.Type,
+			RawContent: rawContent,
+		}
+
+		// Parse wrap if present
+		if raw.Wrap != nil {
+			var wrapRaw rawNode
+			if err := json.Unmarshal(raw.Wrap, &wrapRaw); err != nil {
+				return nil, fmt.Errorf("failed to parse 'wrap' field in unknown node type '%s': %w", raw.Type, err)
+			}
+
+			// Check if the wrapped node is a known type
+			if wrapRaw.Type == "koral:term" || wrapRaw.Type == "koral:token" || wrapRaw.Type == "koral:termGroup" {
+				wrap, err := parseNode(wrapRaw)
+				if err != nil {
+					return nil, fmt.Errorf("error parsing wrapped node in unknown node type '%s': %w", raw.Type, err)
+				}
+				catchall.Wrap = wrap
+			} else {
+				// For unknown types, recursively parse
+				wrap, err := parseNode(wrapRaw)
+				if err != nil {
+					return nil, fmt.Errorf("error parsing wrapped node in unknown node type '%s': %w", raw.Type, err)
+				}
+				catchall.Wrap = wrap
+			}
+		}
+
+		// Parse operands if present
+		if len(raw.Operands) > 0 {
+			operands := make([]ast.Node, len(raw.Operands))
+			for i, op := range raw.Operands {
+				// Check if the operand is a known type
+				if op.Type == "koral:term" || op.Type == "koral:token" || op.Type == "koral:termGroup" {
+					node, err := parseNode(op)
+					if err != nil {
+						return nil, fmt.Errorf("error parsing operand %d in unknown node type '%s': %w", i+1, raw.Type, err)
+					}
+					operands[i] = node
+				} else {
+					// For unknown types, recursively parse
+					node, err := parseNode(op)
+					if err != nil {
+						return nil, fmt.Errorf("error parsing operand %d in unknown node type '%s': %w", i+1, raw.Type, err)
+					}
+					operands[i] = node
+				}
+			}
+			catchall.Operands = operands
+		}
+
+		return catchall, nil
+	}
+}
+
+// SerializeToJSON converts an AST node back to JSON
+func SerializeToJSON(node ast.Node) ([]byte, error) {
+	raw := nodeToRaw(node)
+	return json.MarshalIndent(raw, "", "  ")
+}
+
+// nodeToRaw converts an AST node to a raw node for JSON serialization
+func nodeToRaw(node ast.Node) rawNode {
+	switch n := node.(type) {
+	case *ast.Token:
+		if n.Wrap == nil {
+			return rawNode{
+				Type: "koral:token",
+			}
+		}
+		return rawNode{
+			Type: "koral:token",
+			Wrap: json.RawMessage(nodeToRaw(n.Wrap).toJSON()),
+		}
+
+	case *ast.TermGroup:
+		operands := make([]rawNode, len(n.Operands))
+		for i, op := range n.Operands {
+			operands[i] = nodeToRaw(op)
+		}
+		return rawNode{
+			Type:     "koral:termGroup",
+			Operands: operands,
+			Relation: "relation:" + string(n.Relation),
+		}
+
+	case *ast.Term:
+		raw := rawNode{
+			Type:  "koral:term",
+			Key:   n.Key,
+			Match: "match:" + string(n.Match),
+		}
+		if n.Foundry != "" {
+			raw.Foundry = n.Foundry
+		}
+		if n.Layer != "" {
+			raw.Layer = n.Layer
+		}
+		if n.Value != "" {
+			raw.Value = n.Value
+		}
+		return raw
+
+	case *ast.CatchallNode:
+		// For catchall nodes, use the stored raw content if available
+		if n.RawContent != nil {
+			var raw rawNode
+			if err := json.Unmarshal(n.RawContent, &raw); err == nil {
+				// Ensure we preserve the node type
+				raw.Type = n.NodeType
+
+				// Handle wrap and operands if present
+				if n.Wrap != nil {
+					raw.Wrap = json.RawMessage(nodeToRaw(n.Wrap).toJSON())
+				}
+				if len(n.Operands) > 0 {
+					operands := make([]rawNode, len(n.Operands))
+					for i, op := range n.Operands {
+						operands[i] = nodeToRaw(op)
+					}
+					raw.Operands = operands
+				}
+				return raw
+			}
+		}
+
+		// If RawContent is nil or invalid, create a minimal raw node
+		raw := rawNode{
+			Type: n.NodeType,
+		}
+		if n.Wrap != nil {
+			raw.Wrap = json.RawMessage(nodeToRaw(n.Wrap).toJSON())
+		}
+		if len(n.Operands) > 0 {
+			operands := make([]rawNode, len(n.Operands))
+			for i, op := range n.Operands {
+				operands[i] = nodeToRaw(op)
+			}
+			raw.Operands = operands
+		}
+		return raw
+	}
+
+	// Return a minimal raw node for unknown types
+	return rawNode{
+		Type: "koral:unknown",
+	}
+}
+
+// toJSON converts a raw node to JSON bytes
+func (r rawNode) toJSON() []byte {
+	data, err := json.Marshal(r)
+	if err != nil {
+		// Return a minimal valid JSON object if marshaling fails
+		return []byte(`{"@type":"koral:unknown"}`)
+	}
+	return data
+}