Relationship Detection

text = "Sam Altman is CEO of OpenAI."

# 1. Entities already extracted
entities = [
  %{name: "Sam Altman", type: "person"},
  %{name: "OpenAI", type: "organization"}
]

# 2. Extract relationships between these entities
{:ok, relationships} = RelationshipExtractor.extract(extractor, text, entities)

# Result:
[
  %{
    source: "Sam Altman",
    target: "OpenAI",
    type: "LEADS",
    description: "CEO of",
    strength: 10
  }
]

# 3. Store in graph
# Creates edge: Sam Altman --[LEADS]--> OpenAI

config :arcana, :graph,
  relationship_extractor: {Arcana.Graph.RelationshipExtractor.LLM, []}

extractor = {Arcana.Graph.RelationshipExtractor.LLM, llm: &MyApp.llm/3}

text = """
Sam Altman is CEO of OpenAI, which developed GPT-4. 
The company was founded in San Francisco.
"""

entities = [
  %{name: "Sam Altman", type: "person"},
  %{name: "OpenAI", type: "organization"},
  %{name: "GPT-4", type: "technology"},
  %{name: "San Francisco", type: "location"}
]

{:ok, relationships} = Arcana.Graph.RelationshipExtractor.extract(
  extractor,
  text,
  entities
)

# Returns:
[
  %{
    source: "Sam Altman",
    target: "OpenAI",
    type: "LEADS",
    description: "CEO of",
    strength: 10
  },
  %{
    source: "OpenAI",
    target: "GPT-4",
    type: "DEVELOPED",
    description: "developed the technology",
    strength: 9
  },
  %{
    source: "OpenAI",
    target: "San Francisco",
    type: "LOCATED_IN",
    description: "company founded in",
    strength: 7
  }
]

config :arcana, :graph,
  relationship_extractor: {Arcana.Graph.RelationshipExtractor.Cooccurrence, 
    window_size: 100
  }

config :arcana, :graph,
  relationship_extractor: nil

defmodule MyApp.PatternExtractor do
  @behaviour Arcana.Graph.RelationshipExtractor

  # Patterns like "X is CEO of Y" -> LEADS relationship
  @patterns [
    {~r/(\w+)\s+is\s+CEO\s+of\s+(\w+)/i, "LEADS"},
    {~r/(\w+)\s+founded\s+(\w+)/i, "FOUNDED"},
    {~r/(\w+)\s+works\s+at\s+(\w+)/i, "WORKS_AT"},
    {~r/(\w+)\s+developed\s+(\w+)/i, "DEVELOPED"}
  ]

  @impl true
  def extract(text, entities, opts) do
    patterns = Keyword.get(opts, :patterns, @patterns)
    entity_names = MapSet.new(entities, & &1.name)
    
    relationships =
      patterns
      |> Enum.flat_map(fn {pattern, rel_type} ->
        extract_pattern(text, pattern, rel_type, entity_names)
      end)
    
    {:ok, relationships}
  end

  defp extract_pattern(text, pattern, rel_type, entity_names) do
    Regex.scan(pattern, text)
    |> Enum.map(fn [_full, source, target] ->
      # Verify both entities exist
      if MapSet.member?(entity_names, source) and 
         MapSet.member?(entity_names, target) do
        %{
          source: source,
          target: target,
          type: rel_type,
          strength: 8
        }
      end
    end)
    |> Enum.reject(&is_nil/1)
  end
end

config :arcana, :graph,
  relationship_extractor: {MyApp.PatternExtractor, 
    patterns: [...]  # Custom patterns
  }

def build_prompt(text, entities) do
  entity_list =
    Enum.map_join(entities, "\n", fn %{name: name, type: type} ->
      "- #{name} (#{type})"
    end)

  """
  Analyze the following text and extract relationships between the entities listed below.

  ## Text to analyze:
  #{text}

  ## Entities to find relationships between:
  #{entity_list}

  ## Instructions:
  1. Identify all meaningful relationships between the listed entities
  2. Only include relationships that are explicitly or strongly implied in the text
  3. Use descriptive relationship types in UPPER_SNAKE_CASE (e.g., WORKS_AT, FOUNDED, LEADS, LOCATED_IN)
  4. Rate the strength of each relationship from 1-10 based on how explicit and central it is to the text

  ## Output format:
  Return a JSON array of relationship objects. Each object should have:
  - "source": Name of the source entity (exactly as listed above)
  - "target": Name of the target entity (exactly as listed above)
  - "type": Relationship type in UPPER_SNAKE_CASE
  - "description": Brief description of the relationship (optional)
  - "strength": Integer from 1-10 indicating relationship strength (optional)

  Return only the JSON array, no other text.
  """
end

defp valid_relationship?(%{source: source, target: target, type: type}, entity_names) do
  # Relationship is valid if:
  is_binary(source) and              # Source is a string
    is_binary(target) and            # Target is a string
    is_binary(type) and              # Type is a string
    source != target and             # Not self-referential
    MapSet.member?(entity_names, source) and  # Source entity exists
    MapSet.member?(entity_names, target)      # Target entity exists
end

defp normalize_type(nil), do: nil

defp normalize_type(type) when is_binary(type) do
  type
  |> String.upcase()                # Convert to uppercase
  |> String.replace(~r/[^A-Z0-9_]/, "_")  # Replace non-alphanumeric with _
end

# Examples:
normalize_type("works at")    # => "WORKS_AT"
normalize_type("CEO of")      # => "CEO_OF"
normalize_type("founded-by")  # => "FOUNDED_BY"

defp normalize_strength(nil), do: nil

defp normalize_strength(strength) when is_integer(strength) do
  strength
  |> max(1)   # Minimum 1
  |> min(10)  # Maximum 10
end

defp normalize_strength(strength) when is_binary(strength) do
  case Integer.parse(strength) do
    {val, _} -> normalize_strength(val)
    :error -> nil
  end
end

config :arcana, :graph,
  relationship_extractor: fn text, entities, _opts ->
    # Custom logic
    {:ok, [%{source: "A", target: "B", type: "RELATES_TO"}]}
  end

config :arcana, :graph,
  relationship_extractor: {MyApp.CustomExtractor,
    mode: :strict,
    min_strength: 5
  }

Arcana.Graph.build(chunks,
  entity_extractor: {EntityExtractor.NER, []},
  relationship_extractor: {MyApp.SpecialExtractor, mode: :permissive}
)