brycewang-stanford/citation-network-builder

Citation Network Builder

A skill for constructing, analyzing, and visualizing citation networks from academic reference data. Covers data collection from bibliographic databases, network construction using direct citation, co-citation, and bibliographic coupling methods, community detection for identifying research clusters, and practical visualization with tools like Gephi, VOSviewer, and Python NetworkX.

Data Collection and Preparation

Source Databases

Citation network analysis requires structured bibliographic data with reference lists. The choice of database determines coverage and available metadata.

Database Comparison for Citation Analysis:

Web of Science (Clarivate):
  - Format: ISI/WoS plain text, BibTeX, CSV
  - Coverage: ~21,000 journals, back to 1900
  - Strengths: Cited reference data is most complete
  - Limits: 1,000 records per export, subscription required
  - Best for: High-quality citation network analysis

Scopus (Elsevier):
  - Format: CSV, BibTeX, RIS
  - Coverage: ~27,000 journals, back to 1970s for most
  - Strengths: Broader coverage than WoS, author IDs
  - Limits: 2,000 records per export, subscription required
  - Best for: Broader disciplinary coverage

OpenAlex (free):
  - Format: JSON via REST API
  - Coverage: ~250M works, all disciplines
  - Strengths: Free, open, comprehensive, API access
  - Limits: Reference linking less complete than WoS
  - Best for: Large-scale analysis, reproducible research

CrossRef (free):
  - Format: JSON via REST API
  - Coverage: ~150M DOIs across all publishers
  - Strengths: Free, authoritative DOI metadata, reference linking
  - Limits: No abstract text, citation counts may lag
  - Best for: Cross-publisher networks, DOI resolution

Data Cleaning for Network Construction

import pandas as pd

def clean_bibliographic_data(records):
    """
    Clean and deduplicate bibliographic records for network construction.

    Steps:
    1. Standardize DOIs (lowercase, strip prefixes)
    2. Deduplicate by DOI, then by title similarity
    3. Parse reference lists into structured format
    4. Filter records missing key fields
    """
    # Standardize DOIs
    records["doi"] = (
        records["doi"]
        .str.lower()
        .str.replace("https://doi.org/", "", regex=False)
        .str.replace("http://dx.doi.org/", "", regex=False)
        .str.strip()
    )

    # Remove duplicates by DOI
    records = records.drop_duplicates(subset="doi", keep="first")

    # Filter records without references (cannot build citation links)
    records = records[records["references"].notna()]
    records = records[records["references"].str.len() > 0]

    return records

Network Construction Methods

Direct Citation Network

The simplest approach: paper A cites paper B creates a directed edge from A to B.

import networkx as nx

def build_direct_citation_network(records):
    """
    Build a directed citation network.
    Nodes = papers, Edges = citation relationships.

    Args:
        records: DataFrame with 'doi' and 'references' columns
                 where 'references' is a list of cited DOIs
    Returns:
        NetworkX DiGraph
    """
    G = nx.DiGraph()

    for _, row in records.iterrows():
        citing_doi = row["doi"]
        G.add_node(citing_doi, title=row.get("title", ""),
                   year=row.get("year", None))

        for ref_doi in row["references"]:
            G.add_edge(citing_doi, ref_doi)

    return G

Co-Citation Network

Two papers are co-cited when a third paper cites both. Co-citation strength is the number of papers that cite both. This method identifies intellectual relationships between cited works.

from itertools import combinations
from collections import Counter

def build_cocitation_network(records, min_cocitations=2):
    """
    Build an undirected co-citation network.
    Nodes = cited papers, Edges = co-citation frequency.
    """
    pair_counts = Counter()

    for _, row in records.iterrows():
        refs = sorted(set(row["references"]))
        for a, b in combinations(refs, 2):
            pair_counts[(a, b)] += 1

    G = nx.Graph()
    for (a, b), count in pair_counts.items():
        if count >= min_cocitations:
            G.add_edge(a, b, weight=count)

    return G

Bibliographic Coupling Network

Two papers are bibliographically coupled when they share one or more references. This method groups papers with similar theoretical or methodological foundations.

def build_bibliographic_coupling_network(records, min_shared=3):
    """
    Build an undirected bibliographic coupling network.
    Nodes = citing papers, Edges = number of shared references.
    """
    ref_sets = {}
    for _, row in records.iterrows():
        ref_sets[row["doi"]] = set(row["references"])

    G = nx.Graph()
    dois = list(ref_sets.keys())
    for i in range(len(dois)):
        for j in range(i + 1, len(dois)):
            shared = len(ref_sets[dois[i]] & ref_sets[dois[j]])
            if shared >= min_shared:
                G.add_edge(dois[i], dois[j], weight=shared)

    return G

Network Analysis

Key Metrics

Node-level metrics:
  - In-degree (direct citation): number of times a paper is cited
    -> identifies influential papers
  - Betweenness centrality: how often a node lies on shortest paths
    -> identifies bridging papers connecting subfields
  - PageRank: iterative importance score based on who cites the paper
    -> identifies papers cited by other influential papers

Network-level metrics:
  - Density: proportion of possible edges that exist
  - Clustering coefficient: tendency of nodes to form triangles
  - Average path length: mean shortest path between node pairs
  - Number of connected components: isolated clusters

Community Detection

Community detection algorithms identify clusters of densely connected papers, corresponding to research subfields or intellectual traditions.

import community as community_louvain

def detect_communities(G):
    """
    Detect communities using the Louvain algorithm.
    Returns a dictionary mapping node -> community_id.
    """
    partition = community_louvain.best_partition(G, weight="weight")

    # Summarize communities
    communities = {}
    for node, comm_id in partition.items():
        communities.setdefault(comm_id, []).append(node)

    for comm_id, members in sorted(communities.items()):
        print(f"Community {comm_id}: {len(members)} papers")

    return partition

Visualization

Tool Recommendations

Gephi (desktop application):
  - Best for: Interactive exploration of medium networks (1k-50k nodes)
  - Layout algorithms: ForceAtlas2, Fruchterman-Reingold
  - Export: SVG, PDF, PNG
  - Workflow: Import GEXF/GraphML -> layout -> partition by community
              -> adjust sizes by centrality -> export

VOSviewer (desktop application):
  - Best for: Bibliometric networks specifically
  - Direct import from WoS/Scopus export files
  - Built-in clustering and overlay visualizations
  - Limitation: less customizable than Gephi

Python (matplotlib, pyvis):
  - Best for: Reproducible, scriptable visualizations
  - Use pyvis for interactive HTML network graphs
  - Use matplotlib for static publication-quality figures

Citation network analysis provides a quantitative lens on the structure of scientific knowledge, revealing invisible colleges, emerging research fronts, and foundational works that shape entire disciplines.