Research analysis

# Trace research lineage
result = await drift_search.search(
    "How did the transformer architecture influence modern language models like GPT and BERT?"
)

# Cross-domain connections
result = await drift_search.search(
    "How have computer vision techniques influenced natural language processing?"
)

# Collaboration networks
result = await drift_search.search(
    "How are researchers at Google and OpenAI connected through co-authors and citations?"
)

import pandas as pd
import matplotlib.pyplot as plt

# Load entities with temporal data
entities = pd.read_parquet('./output/entities.parquet')

# Filter for CONCEPT entities
concepts = entities[entities['type'] == 'CONCEPT']

# Analyze concept emergence by year
# (assuming year is in entity metadata)
concept_timeline = concepts.groupby(['name', 'year']).size().unstack(fill_value=0)

# Plot concept trends
concept_timeline.T.plot(figsize=(12, 6))
plt.title('Emergence of Research Concepts Over Time')
plt.xlabel('Year')
plt.ylabel('Mentions')
plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
plt.tight_layout()
plt.show()

import networkx as nx

# Load relationships
relationships = pd.read_parquet('./output/relationships.parquet')

# Create citation network
citations = relationships[relationships['description'].str.contains('cites', case=False)]

G = nx.DiGraph()
for _, row in citations.iterrows():
    G.add_edge(row['source'], row['target'], weight=row.get('weight', 1))

# Calculate influential papers (high in-degree)
influential = sorted(G.in_degree(), key=lambda x: x[1], reverse=True)[:10]

print("Most cited papers:")
for paper, citations in influential:
    print(f"{paper}: {citations} citations")

# Identify seminal papers (high betweenness centrality)
betweenness = nx.betweenness_centrality(G)
seminal = sorted(betweenness.items(), key=lambda x: x[1], reverse=True)[:10]

print("\nSeminal papers (high betweenness):")
for paper, score in seminal:
    print(f"{paper}: {score:.4f}")

# Find research communities
from graphrag.query.community_detection import detect_communities

# Load author collaboration network
collaborations = relationships[
    relationships['description'].str.contains('co-author|collaborated', case=False)
]

# Build collaboration graph
G_collab = nx.Graph()
for _, row in collaborations.iterrows():
    G_collab.add_edge(row['source'], row['target'])

# Detect research communities
communities = nx.community.greedy_modularity_communities(G_collab)

print(f"Found {len(communities)} research communities")

for i, community in enumerate(communities[:5], 1):
    print(f"\nCommunity {i} ({len(community)} researchers):")
    print(", ".join(list(community)[:10]))

# Generate comprehensive literature review
graphrag query \
  "Provide a structured literature review of transformer-based language models, \
  including key papers, methodological evolution, and current state of the art" \
  --method global

# Identify underexplored connections
result = await drift_search.search(
    "What concepts are frequently mentioned together but lack direct research connecting them?"
)

print(result.response)

graphrag query \
  "How have the evaluation methodologies for language models evolved?" \
  --method global

import json

# Export for Gephi or other network visualization tools
entities = pd.read_parquet('./output/entities.parquet')
relationships = pd.read_parquet('./output/relationships.parquet')

# Create nodes file
nodes = entities[['name', 'type', 'description']].to_dict('records')
with open('nodes.json', 'w') as f:
    json.dump(nodes, f, indent=2)

# Create edges file
edges = relationships[['source', 'target', 'description', 'weight']].to_dict('records')
with open('edges.json', 'w') as f:
    json.dump(edges, f, indent=2)

import bibtexparser

# Import from BibTeX
with open('references.bib') as bibtex_file:
    bib_database = bibtexparser.load(bibtex_file)

# Convert to GraphRAG CSV format
papers = []
for entry in bib_database.entries:
    papers.append({
        'id': entry.get('ID'),
        'title': entry.get('title'),
        'authors': entry.get('author'),
        'year': entry.get('year'),
        'venue': entry.get('journal') or entry.get('booktitle'),
        'abstract': entry.get('abstract', ''),
    })

papers_df = pd.DataFrame(papers)
papers_df.to_csv('input/papers.csv', index=False)

{
  "entities": [
    {
      "name": "BERT",
      "type": "MODEL",
      "description": "Bidirectional Encoder Representations from Transformers, a pre-trained language model"
    },
    {
      "name": "Jacob Devlin",
      "type": "RESEARCHER",
      "description": "Researcher at Google AI Language, lead author of BERT paper"
    },
    {
      "name": "masked language modeling",
      "type": "CONCEPT",
      "description": "Training objective that masks tokens and predicts them from context"
    }
  ],
  "relationships": [
    {
      "source": "Jacob Devlin",
      "target": "BERT",
      "description": "authored and introduced"
    },
    {
      "source": "BERT",
      "target": "masked language modeling",
      "description": "uses as primary training objective"
    }
  ]
}

entity_extraction:
  entity_types: [
    # Computer Science
    ALGORITHM, MODEL, SYSTEM,
    # Biology
    PROTEIN, GENE, ORGANISM,
    # Chemistry  
    MOLECULE, REACTION, COMPOUND,
    # Shared
    RESEARCHER, INSTITUTION, CONCEPT, METHOD
  ]