diff --git a/catalog-analytics/.env.example b/catalog-analytics/.env.example
index 54158b4..9442b6c 100644
--- a/catalog-analytics/.env.example
+++ b/catalog-analytics/.env.example
@@ -11,3 +11,8 @@ REDIRECT_URI=https://catalog.vectorinstitute.ai/analytics/api/auth/callback
 
 # Domain Restrictions (comma-separated)
 ALLOWED_DOMAINS=vectorinstitute.ai
+
+# GitHub Configuration (for CI status checks)
+# Note: Use GH_TOKEN in GitHub Actions (GITHUB_* is reserved)
+GH_TOKEN=your-github-personal-access-token
+# Alternative names supported: CATALOG_GITHUB_TOKEN, GITHUB_TOKEN, METRICS_GITHUB_TOKEN
diff --git a/catalog-analytics/app/analytics-content.tsx b/catalog-analytics/app/analytics-content.tsx
index 532c7cc..2944302 100644
--- a/catalog-analytics/app/analytics-content.tsx
+++ b/catalog-analytics/app/analytics-content.tsx
@@ -43,6 +43,14 @@ interface RepoSnapshot {
   topics: string[];
 }
 
+interface CIStatus {
+  repo_id: string;
+  state: 'success' | 'failure' | 'pending' | 'error' | 'unknown';
+  total_checks: number;
+  updated_at: string;
+  details?: string;
+}
+
 interface RepoHistory {
   name: string;
   snapshots: RepoSnapshot[];
@@ -108,7 +116,7 @@ interface PyPIMetrics {
   description?: string;
 }
 
-type SortColumn = "name" | "language" | "stars" | "forks" | "unique_visitors" | "unique_cloners";
+type SortColumn = "name" | "language" | "stars" | "forks" | "unique_visitors" | "unique_cloners" | "ci_status";
 type PyPISortColumn = "name" | "downloads_last_day" | "downloads_last_week" | "downloads_last_month" | "version";
 type SortDirection = "asc" | "desc";
 type ActiveTab = "github" | "pypi";
@@ -128,8 +136,18 @@ export default function AnalyticsPage({ user }: AnalyticsPageProps) {
   const [pypiSortColumn, setPypiSortColumn] = useState<PyPISortColumn>("downloads_last_month");
   const [sortDirection, setSortDirection] = useState<SortDirection>("desc");
   const [pypiSortDirection, setPypiSortDirection] = useState<SortDirection>("desc");
+  const [templateSortColumn, setTemplateSortColumn] = useState<SortColumn>("unique_cloners");
+  const [templateSortDirection, setTemplateSortDirection] = useState<SortDirection>("desc");
   const [activeTab, setActiveTab] = useState<ActiveTab>("github");
   const [pypiFilter, setPypiFilter] = useState<PyPIFilter>("all");
+  const [ciStatuses, setCiStatuses] = useState<Record<string, CIStatus>>({});
+  const [ciLoading, setCiLoading] = useState(false);
+  const [ciCache, setCiCache] = useState<{
+    data: Record<string, CIStatus>;
+    timestamp: number;
+  } | null>(null);
+
+  const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
 
   const handleLogout = async () => {
     try {
@@ -215,15 +233,79 @@ export default function AnalyticsPage({ user }: AnalyticsPageProps) {
       .filter((r): r is RepoMetrics => r !== null);
   }, [historicalData, repoDescriptions]);
 
-  // Calculate aggregate metrics
+  // Separate regular repos from template repos
+  const regularRepoMetrics = useMemo(() => {
+    return allRepoMetrics.filter(repo => !repo.name.startsWith('aieng-template-'));
+  }, [allRepoMetrics]);
+
+  const templateRepoMetrics = useMemo(() => {
+    return allRepoMetrics.filter(repo =>
+      repo.name.startsWith('aieng-template-') &&
+      repo.name !== 'aieng-template-poetry'
+    );
+  }, [allRepoMetrics]);
+
+  // Fetch CI statuses when repo metrics are loaded
+  useEffect(() => {
+    const fetchCIStatuses = async () => {
+      if (allRepoMetrics.length === 0) return;
+
+      // Check cache validity
+      const isCacheValid = ciCache && (Date.now() - ciCache.timestamp) < CACHE_DURATION;
+      if (isCacheValid) {
+        setCiStatuses(ciCache.data);
+        return;
+      }
+
+      setCiLoading(true);
+
+      try {
+        const repoIds = allRepoMetrics.map(r => r.repo_id);
+        const basePath = "/analytics";
+
+        const response = await fetch(`${basePath}/api/github/ci-status`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({ repositories: repoIds }),
+        });
+
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
+          console.error('CI status API error:', response.status, errorData);
+          throw new Error(`Failed to fetch CI statuses: ${response.status} - ${errorData.error || 'Unknown error'}`);
+        }
+
+        const data = await response.json();
+        setCiStatuses(data);
+
+        // Update cache
+        setCiCache({
+          data,
+          timestamp: Date.now(),
+        });
+      } catch (error) {
+        console.error('Error fetching CI statuses:', error);
+        // Set empty object so we don't keep retrying
+        setCiStatuses({});
+      } finally {
+        setCiLoading(false);
+      }
+    };
+
+    fetchCIStatuses();
+  }, [allRepoMetrics, ciCache, CACHE_DURATION]);
+
+  // Calculate aggregate metrics (using regular repos only, excluding templates)
   const aggregateMetrics = useMemo(() => {
-    const totalStars = allRepoMetrics.reduce((sum, r) => sum + r.stars, 0);
-    const totalForks = allRepoMetrics.reduce((sum, r) => sum + r.forks, 0);
-    const totalVisitors = allRepoMetrics.reduce(
+    const totalStars = regularRepoMetrics.reduce((sum, r) => sum + r.stars, 0);
+    const totalForks = regularRepoMetrics.reduce((sum, r) => sum + r.forks, 0);
+    const totalVisitors = regularRepoMetrics.reduce(
       (sum, r) => sum + r.unique_visitors,
       0
     );
-    const totalCloners = allRepoMetrics.reduce(
+    const totalCloners = regularRepoMetrics.reduce(
       (sum, r) => sum + r.unique_cloners,
       0
     );
@@ -233,30 +315,52 @@ export default function AnalyticsPage({ user }: AnalyticsPageProps) {
       totalForks,
       totalVisitors,
       totalCloners,
-      totalRepos: allRepoMetrics.length,
+      totalRepos: regularRepoMetrics.length,
       avgStarsPerRepo:
-        allRepoMetrics.length > 0
-          ? Math.round(totalStars / allRepoMetrics.length)
+        regularRepoMetrics.length > 0
+          ? Math.round(totalStars / regularRepoMetrics.length)
           : 0,
     };
-  }, [allRepoMetrics]);
+  }, [regularRepoMetrics]);
 
-  // Get top performers
+  // Get top performers (using regular repos only, excluding templates)
   const topPerformers = useMemo(() => {
     return {
-      byStars: [...allRepoMetrics].sort((a, b) => b.stars - a.stars).slice(0, 5),
-      byVisitors: [...allRepoMetrics]
+      byStars: [...regularRepoMetrics].sort((a, b) => b.stars - a.stars).slice(0, 5),
+      byVisitors: [...regularRepoMetrics]
         .sort((a, b) => b.unique_visitors - a.unique_visitors)
         .slice(0, 5),
-      byCloners: [...allRepoMetrics]
+      byCloners: [...regularRepoMetrics]
         .sort((a, b) => b.unique_cloners - a.unique_cloners)
         .slice(0, 5),
     };
-  }, [allRepoMetrics]);
+  }, [regularRepoMetrics]);
 
-  // Sort repository metrics
+  // Sort repository metrics (regular repos only, excluding templates)
   const sortedRepoMetrics = useMemo(() => {
-    const sorted = [...allRepoMetrics].sort((a, b) => {
+    const sorted = [...regularRepoMetrics].sort((a, b) => {
+      // Special handling for CI status column
+      if (sortColumn === 'ci_status') {
+        const statusA = ciStatuses[a.repo_id]?.state || 'unknown';
+        const statusB = ciStatuses[b.repo_id]?.state || 'unknown';
+
+        // Define sort order: success > pending > failure/error > unknown
+        const statusOrder: Record<string, number> = {
+          success: 4,
+          pending: 3,
+          failure: 2,
+          error: 2,
+          unknown: 1,
+        };
+
+        const orderA = statusOrder[statusA] || 0;
+        const orderB = statusOrder[statusB] || 0;
+
+        return sortDirection === 'asc'
+          ? orderA - orderB
+          : orderB - orderA;
+      }
+
       let aValue: string | number | null = a[sortColumn];
       let bValue: string | number | null = b[sortColumn];
 
@@ -278,7 +382,55 @@ export default function AnalyticsPage({ user }: AnalyticsPageProps) {
     });
 
     return sorted;
-  }, [allRepoMetrics, sortColumn, sortDirection]);
+  }, [regularRepoMetrics, sortColumn, sortDirection, ciStatuses]);
+
+  // Sort template repository metrics
+  const sortedTemplateMetrics = useMemo(() => {
+    const sorted = [...templateRepoMetrics].sort((a, b) => {
+      // Special handling for CI status column
+      if (templateSortColumn === 'ci_status') {
+        const statusA = ciStatuses[a.repo_id]?.state || 'unknown';
+        const statusB = ciStatuses[b.repo_id]?.state || 'unknown';
+
+        // Define sort order: success > pending > failure/error > unknown
+        const statusOrder: Record<string, number> = {
+          success: 4,
+          pending: 3,
+          failure: 2,
+          error: 2,
+          unknown: 1,
+        };
+
+        const orderA = statusOrder[statusA] || 0;
+        const orderB = statusOrder[statusB] || 0;
+
+        return templateSortDirection === 'asc'
+          ? orderA - orderB
+          : orderB - orderA;
+      }
+
+      let aValue: string | number | null = a[templateSortColumn];
+      let bValue: string | number | null = b[templateSortColumn];
+
+      // Handle null/undefined values
+      if (aValue === null || aValue === undefined) aValue = "";
+      if (bValue === null || bValue === undefined) bValue = "";
+
+      // For strings, use locale compare
+      if (typeof aValue === "string" && typeof bValue === "string") {
+        return templateSortDirection === "asc"
+          ? aValue.localeCompare(bValue)
+          : bValue.localeCompare(aValue);
+      }
+
+      // For numbers
+      return templateSortDirection === "asc"
+        ? (aValue as number) - (bValue as number)
+        : (bValue as number) - (aValue as number);
+    });
+
+    return sorted;
+  }, [templateRepoMetrics, templateSortColumn, templateSortDirection, ciStatuses]);
 
   // Handle column header click
   const handleSort = (column: SortColumn) => {
@@ -302,6 +454,28 @@ export default function AnalyticsPage({ user }: AnalyticsPageProps) {
     );
   };
 
+  // Handle template column header click
+  const handleTemplateSort = (column: SortColumn) => {
+    if (templateSortColumn === column) {
+      setTemplateSortDirection(templateSortDirection === "asc" ? "desc" : "asc");
+    } else {
+      setTemplateSortColumn(column);
+      setTemplateSortDirection("desc");
+    }
+  };
+
+  // Get template sort icon for a column
+  const getTemplateSortIcon = (column: SortColumn) => {
+    if (templateSortColumn !== column) {
+      return <ArrowUpDown className="w-3 h-3 opacity-50" />;
+    }
+    return templateSortDirection === "asc" ? (
+      <ArrowUp className="w-3 h-3" />
+    ) : (
+      <ArrowDown className="w-3 h-3" />
+    );
+  };
+
   // PyPI Metrics Calculations
   const allPypiMetrics = useMemo(() => {
     if (!pypiData?.packages) return [];
@@ -648,140 +822,31 @@ export default function AnalyticsPage({ user }: AnalyticsPageProps) {
               </div>
             </section>
 
-            {/* All Repositories Table */}
-            <section>
-              <h2 className="text-2xl font-bold text-gray-900 dark:text-white mb-6">
-                All Repositories
-              </h2>
-              <div className="bg-white dark:bg-gray-800 rounded-xl border border-gray-200 dark:border-gray-700 overflow-hidden shadow-sm">
-                <div className="overflow-x-auto">
-                  <table className="w-full">
-                    <thead className="bg-gray-50 dark:bg-gray-900 border-b border-gray-200 dark:border-gray-700">
-                      <tr>
-                        <th
-                          className="px-6 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
-                          onClick={() => handleSort("name")}
-                        >
-                          <div className="flex items-center gap-2">
-                            Repository
-                            {getSortIcon("name")}
-                          </div>
-                        </th>
-                        <th
-                          className="px-6 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
-                          onClick={() => handleSort("language")}
-                        >
-                          <div className="flex items-center gap-2">
-                            Language
-                            {getSortIcon("language")}
-                          </div>
-                        </th>
-                        <th
-                          className="px-6 py-3 text-right text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
-                          onClick={() => handleSort("stars")}
-                        >
-                          <div className="flex items-center justify-end gap-1">
-                            <Star className="w-3 h-3" />
-                            Stars
-                            {getSortIcon("stars")}
-                          </div>
-                        </th>
-                        <th
-                          className="px-6 py-3 text-right text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
-                          onClick={() => handleSort("forks")}
-                        >
-                          <div className="flex items-center justify-end gap-1">
-                            <GitFork className="w-3 h-3" />
-                            Forks
-                            {getSortIcon("forks")}
-                          </div>
-                        </th>
-                        <th
-                          className="px-6 py-3 text-right text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
-                          onClick={() => handleSort("unique_visitors")}
-                        >
-                          <div className="flex items-center justify-end gap-1">
-                            <Eye className="w-3 h-3" />
-                            Visitors (14d)
-                            {getSortIcon("unique_visitors")}
-                          </div>
-                        </th>
-                        <th
-                          className="px-6 py-3 text-right text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
-                          onClick={() => handleSort("unique_cloners")}
-                        >
-                          <div className="flex items-center justify-end gap-1">
-                            <Download className="w-3 h-3" />
-                            Cloners (14d)
-                            {getSortIcon("unique_cloners")}
-                          </div>
-                        </th>
-                      </tr>
-                    </thead>
-                    <tbody className="divide-y divide-gray-200 dark:divide-gray-700">
-                      {sortedRepoMetrics.map((repo, index) => {
-                        // Show tooltip below for first 3 rows, above for the rest
-                        const showTooltipBelow = index < 3;
-                        return (
-                        <motion.tr
-                          key={repo.repo_id}
-                          initial={{ opacity: 0, y: 10 }}
-                          animate={{ opacity: 1, y: 0 }}
-                          transition={{ duration: 0.3, delay: index * 0.02 }}
-                          className="hover:bg-gray-50 dark:hover:bg-gray-750 transition-colors group"
-                        >
-                          <td
-                            className="px-6 py-4 whitespace-nowrap relative"
-                          >
-                            <a
-                              href={`https://github.com/${repo.repo_id}`}
-                              target="_blank"
-                              rel="noopener noreferrer"
-                              className="flex items-center gap-2 text-sm font-medium text-vector-magenta hover:text-vector-cobalt dark:text-vector-magenta dark:hover:text-vector-cobalt"
-                            >
-                              {repo.name}
-                              <ExternalLink className="w-3 h-3" />
-                            </a>
-                            {repo.description && (
-                              <div className={`hidden group-hover:block absolute left-0 ${showTooltipBelow ? 'top-full mt-2' : 'bottom-full mb-2'} z-50 bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 text-sm rounded-lg py-3 px-4 w-96 max-w-[calc(100vw-2rem)] shadow-xl border-2 border-gray-200 dark:border-gray-600 leading-relaxed whitespace-normal break-words`}>
-                                {repo.description}
-                                <div className={`absolute ${showTooltipBelow ? '-top-2 left-8 border-l-2 border-t-2' : '-bottom-2 left-8 border-r-2 border-b-2'} w-4 h-4 bg-white dark:bg-gray-800 border-gray-200 dark:border-gray-600 transform rotate-45`}></div>
-                              </div>
-                            )}
-                          </td>
-                            <td className="px-6 py-4 whitespace-nowrap">
-                              {repo.language ? (
-                                <span className="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-gray-100 dark:bg-gray-700 text-gray-800 dark:text-gray-200">
-                                  {repo.language}
-                                </span>
-                              ) : (
-                                <span className="text-xs text-gray-400">—</span>
-                              )}
-                            </td>
-                            <td className="px-6 py-4 whitespace-nowrap text-right text-sm font-medium text-gray-900 dark:text-white">
-                              {repo.stars.toLocaleString()}
-                            </td>
-                            <td className="px-6 py-4 whitespace-nowrap text-right text-sm text-gray-600 dark:text-gray-400">
-                              {repo.forks.toLocaleString()}
-                            </td>
-                            <td className="px-6 py-4 whitespace-nowrap text-right text-sm text-gray-600 dark:text-gray-400">
-                              {repo.unique_visitors > 0
-                                ? repo.unique_visitors.toLocaleString()
-                                : "—"}
-                            </td>
-                            <td className="px-6 py-4 whitespace-nowrap text-right text-sm text-gray-600 dark:text-gray-400">
-                              {repo.unique_cloners > 0
-                                ? repo.unique_cloners.toLocaleString()
-                                : "—"}
-                            </td>
-                          </motion.tr>
-                        );
-                      })}
-                    </tbody>
-                  </table>
-                </div>
-              </div>
-            </section>
+            {/* Repositories Table */}
+            <RepositoryTable
+              title="Repositories"
+              repos={sortedRepoMetrics}
+              ciStatuses={ciStatuses}
+              ciLoading={ciLoading}
+              sortColumn={sortColumn}
+              sortDirection={sortDirection}
+              onSort={handleSort}
+              getSortIcon={getSortIcon}
+            />
+
+            {/* Template Repositories Table */}
+            {templateRepoMetrics.length > 0 && (
+              <RepositoryTable
+                title="Template Repositories"
+                repos={sortedTemplateMetrics}
+                ciStatuses={ciStatuses}
+                ciLoading={ciLoading}
+                sortColumn={templateSortColumn}
+                sortDirection={templateSortDirection}
+                onSort={handleTemplateSort}
+                getSortIcon={getTemplateSortIcon}
+              />
+            )}
               </>
             )}
 
@@ -1090,6 +1155,176 @@ export default function AnalyticsPage({ user }: AnalyticsPageProps) {
   );
 }
 
+// Reusable Repository Table Component
+function RepositoryTable({
+  title,
+  repos,
+  ciStatuses,
+  ciLoading,
+  sortColumn,
+  sortDirection,
+  onSort,
+  getSortIcon,
+}: {
+  title: string;
+  repos: RepoMetrics[];
+  ciStatuses: Record<string, CIStatus>;
+  ciLoading: boolean;
+  sortColumn: SortColumn;
+  sortDirection: SortDirection;
+  onSort: (column: SortColumn) => void;
+  getSortIcon: (column: SortColumn) => React.ReactNode;
+}) {
+  return (
+    <section className="mt-12">
+      <h2 className="text-2xl font-bold text-gray-900 dark:text-white mb-6">
+        {title}
+      </h2>
+      <div className="bg-white dark:bg-gray-800 rounded-xl border border-gray-200 dark:border-gray-700 overflow-hidden shadow-sm">
+        <div className="overflow-x-auto">
+          <table className="w-full">
+            <thead className="bg-gray-50 dark:bg-gray-900 border-b border-gray-200 dark:border-gray-700">
+              <tr>
+                <th
+                  className="px-6 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
+                  onClick={() => onSort("name")}
+                >
+                  <div className="flex items-center gap-2">
+                    Repository
+                    {getSortIcon("name")}
+                  </div>
+                </th>
+                <th
+                  className="px-6 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
+                  onClick={() => onSort("language")}
+                >
+                  <div className="flex items-center gap-2">
+                    Language
+                    {getSortIcon("language")}
+                  </div>
+                </th>
+                <th
+                  className="px-6 py-3 text-right text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
+                  onClick={() => onSort("stars")}
+                >
+                  <div className="flex items-center justify-end gap-1">
+                    <Star className="w-3 h-3" />
+                    Stars
+                    {getSortIcon("stars")}
+                  </div>
+                </th>
+                <th
+                  className="px-6 py-3 text-right text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
+                  onClick={() => onSort("forks")}
+                >
+                  <div className="flex items-center justify-end gap-1">
+                    <GitFork className="w-3 h-3" />
+                    Forks
+                    {getSortIcon("forks")}
+                  </div>
+                </th>
+                <th
+                  className="px-6 py-3 text-right text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
+                  onClick={() => onSort("unique_visitors")}
+                >
+                  <div className="flex items-center justify-end gap-1">
+                    <Eye className="w-3 h-3" />
+                    Visitors (14d)
+                    {getSortIcon("unique_visitors")}
+                  </div>
+                </th>
+                <th
+                  className="px-6 py-3 text-right text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
+                  onClick={() => onSort("unique_cloners")}
+                >
+                  <div className="flex items-center justify-end gap-1">
+                    <Download className="w-3 h-3" />
+                    Cloners (14d)
+                    {getSortIcon("unique_cloners")}
+                  </div>
+                </th>
+                <th
+                  className="px-6 py-3 text-center text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider cursor-pointer hover:bg-gray-100 dark:hover:bg-gray-800 transition-colors"
+                  onClick={() => onSort("ci_status")}
+                >
+                  <div className="flex items-center justify-center gap-1">
+                    CI Status
+                    {getSortIcon("ci_status")}
+                  </div>
+                </th>
+              </tr>
+            </thead>
+            <tbody className="divide-y divide-gray-200 dark:divide-gray-700">
+              {repos.map((repo, index) => {
+                const showTooltipBelow = index < 3;
+                return (
+                  <motion.tr
+                    key={repo.repo_id}
+                    initial={{ opacity: 0, y: 10 }}
+                    animate={{ opacity: 1, y: 0 }}
+                    transition={{ duration: 0.3, delay: index * 0.02 }}
+                    className="hover:bg-gray-50 dark:hover:bg-gray-750 transition-colors group"
+                  >
+                    <td className="px-6 py-4 whitespace-nowrap relative">
+                      <a
+                        href={`https://github.com/${repo.repo_id}`}
+                        target="_blank"
+                        rel="noopener noreferrer"
+                        className="flex items-center gap-2 text-sm font-medium text-vector-magenta hover:text-vector-cobalt dark:text-vector-magenta dark:hover:text-vector-cobalt"
+                      >
+                        {repo.name}
+                        <ExternalLink className="w-3 h-3" />
+                      </a>
+                      {repo.description && (
+                        <div className={`hidden group-hover:block absolute left-0 ${showTooltipBelow ? 'top-full mt-2' : 'bottom-full mb-2'} z-50 bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 text-sm rounded-lg py-3 px-4 w-96 max-w-[calc(100vw-2rem)] shadow-xl border-2 border-gray-200 dark:border-gray-600 leading-relaxed whitespace-normal break-words`}>
+                          {repo.description}
+                          <div className={`absolute ${showTooltipBelow ? '-top-2 left-8 border-l-2 border-t-2' : '-bottom-2 left-8 border-r-2 border-b-2'} w-4 h-4 bg-white dark:bg-gray-800 border-gray-200 dark:border-gray-600 transform rotate-45`}></div>
+                        </div>
+                      )}
+                    </td>
+                    <td className="px-6 py-4 whitespace-nowrap">
+                      {repo.language ? (
+                        <span className="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-gray-100 dark:bg-gray-700 text-gray-800 dark:text-gray-200">
+                          {repo.language}
+                        </span>
+                      ) : (
+                        <span className="text-xs text-gray-400">—</span>
+                      )}
+                    </td>
+                    <td className="px-6 py-4 whitespace-nowrap text-right text-sm font-medium text-gray-900 dark:text-white">
+                      {repo.stars.toLocaleString()}
+                    </td>
+                    <td className="px-6 py-4 whitespace-nowrap text-right text-sm text-gray-600 dark:text-gray-400">
+                      {repo.forks.toLocaleString()}
+                    </td>
+                    <td className="px-6 py-4 whitespace-nowrap text-right text-sm text-gray-600 dark:text-gray-400">
+                      {repo.unique_visitors > 0
+                        ? repo.unique_visitors.toLocaleString()
+                        : "—"}
+                    </td>
+                    <td className="px-6 py-4 whitespace-nowrap text-right text-sm text-gray-600 dark:text-gray-400">
+                      {repo.unique_cloners > 0
+                        ? repo.unique_cloners.toLocaleString()
+                        : "—"}
+                    </td>
+                    <td className="px-6 py-4 whitespace-nowrap text-center">
+                      <CIStatusBadge
+                        status={ciStatuses[repo.repo_id]}
+                        loading={ciLoading}
+                        showTooltipBelow={showTooltipBelow}
+                      />
+                    </td>
+                  </motion.tr>
+                );
+              })}
+            </tbody>
+          </table>
+        </div>
+      </div>
+    </section>
+  );
+}
+
 // Metric Card Component
 function MetricCard({
   icon,
@@ -1257,3 +1492,75 @@ function TopPypiPerformerCard({
     </motion.div>
   );
 }
+
+// CI Status Badge Component (Icon-only)
+function CIStatusBadge({
+  status,
+  loading,
+  showTooltipBelow,
+}: {
+  status: CIStatus | undefined;
+  loading: boolean;
+  showTooltipBelow: boolean;
+}) {
+  if (loading) {
+    return (
+      <div className="flex items-center justify-center">
+        <div className="w-4 h-4 border-2 border-gray-300 border-t-vector-magenta rounded-full animate-spin"></div>
+      </div>
+    );
+  }
+
+  if (!status || status.state === 'unknown') {
+    return (
+      <span className="text-sm text-gray-400">—</span>
+    );
+  }
+
+  const statusConfig = {
+    success: {
+      icon: '✓',
+      color: 'text-green-600 dark:text-green-400',
+      label: 'Passing',
+    },
+    failure: {
+      icon: '✗',
+      color: 'text-red-600 dark:text-red-400',
+      label: 'Failed',
+    },
+    error: {
+      icon: '✗',
+      color: 'text-red-600 dark:text-red-400',
+      label: 'Error',
+    },
+    pending: {
+      icon: '⚠',
+      color: 'text-yellow-600 dark:text-yellow-400',
+      label: 'Pending',
+    },
+    unknown: {
+      icon: '—',
+      color: 'text-gray-400',
+      label: 'Unknown',
+    },
+  };
+
+  const config = statusConfig[status.state];
+
+  return (
+    <div className="relative group inline-flex items-center justify-center">
+      <span className={`text-base font-semibold ${config.color}`}>
+        {config.icon}
+      </span>
+      {/* Tooltip - right aligned to prevent cutoff */}
+      <div className={`hidden group-hover:block absolute right-0 ${showTooltipBelow ? 'top-full mt-2' : 'bottom-full mb-2'} z-50 bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 text-xs rounded-lg py-2 px-3 whitespace-nowrap shadow-xl border-2 border-gray-200 dark:border-gray-600`}>
+        <div className="font-medium mb-1">{config.label}</div>
+        <div className="text-gray-600 dark:text-gray-400">{status.details}</div>
+        <div className="text-gray-500 dark:text-gray-500 text-[10px] mt-1">
+          Updated: {new Date(status.updated_at).toLocaleString()}
+        </div>
+        <div className={`absolute right-2 ${showTooltipBelow ? '-top-2 border-l-2 border-t-2' : '-bottom-2 border-r-2 border-b-2'} w-4 h-4 bg-white dark:bg-gray-800 border-gray-200 dark:border-gray-600 transform rotate-45`}></div>
+      </div>
+    </div>
+  );
+}
diff --git a/catalog-analytics/app/api/github/ci-status/route.ts b/catalog-analytics/app/api/github/ci-status/route.ts
new file mode 100644
index 0000000..f4292f9
--- /dev/null
+++ b/catalog-analytics/app/api/github/ci-status/route.ts
@@ -0,0 +1,231 @@
+import { NextResponse } from 'next/server';
+
+export const dynamic = 'force-dynamic';
+
+interface CIStatusRequest {
+  repositories: string[]; // Array of repo_ids like "VectorInstitute/cyclops"
+}
+
+interface CIStatus {
+  repo_id: string;
+  state: 'success' | 'failure' | 'pending' | 'error' | 'unknown';
+  total_checks: number;
+  updated_at: string;
+  details?: string;
+}
+
+function isValidRepoId(repo_id: string): boolean {
+  // Expect GitHub-style "owner/repo" with safe characters only
+  const trimmed = repo_id.trim();
+  const repoPattern = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+  return repoPattern.test(trimmed);
+}
+
+function isValidCommitSha(sha: string): boolean {
+  // Git SHAs are 40-character hexadecimal strings
+  const shaPattern = /^[a-f0-9]{40}$/;
+  return shaPattern.test(sha);
+}
+
+function buildGitHubApiUrl(path: string): URL {
+  // Always use the official GitHub API base URL to prevent SSRF
+  const baseUrl = 'https://api.github.com';
+  // URL constructor will throw if path is malformed
+  return new URL(path, baseUrl);
+}
+
+export async function POST(request: Request) {
+  try {
+    const { repositories }: CIStatusRequest = await request.json();
+
+    if (!Array.isArray(repositories)) {
+      return NextResponse.json(
+        { error: 'Invalid request: "repositories" must be an array of strings' },
+        { status: 400 }
+      );
+    }
+
+    const token = process.env.GH_TOKEN || process.env.CATALOG_GITHUB_TOKEN || process.env.GITHUB_TOKEN || process.env.METRICS_GITHUB_TOKEN;
+
+    if (!token) {
+      // Return unknown status for all repos if token is not configured
+      const statusMap = repositories.reduce((acc, repo_id) => {
+        acc[repo_id] = {
+          repo_id,
+          state: 'unknown' as const,
+          total_checks: 0,
+          updated_at: new Date().toISOString(),
+          details: 'GitHub token not configured',
+        };
+        return acc;
+      }, {} as Record<string, CIStatus>);
+
+      return NextResponse.json(statusMap);
+    }
+
+    // Fetch CI status for all repos in parallel
+    const statusPromises = repositories.map(async (repo_id) => {
+      // Validate repo_id before using it in an outbound request
+      const repoIdStr = String(repo_id).trim();
+      if (!isValidRepoId(repoIdStr)) {
+        return {
+          repo_id: repoIdStr,
+          state: 'unknown' as const,
+          total_checks: 0,
+          updated_at: new Date().toISOString(),
+          details: 'Invalid repository identifier',
+        };
+      }
+
+      try {
+        // First, get the latest commit SHA on main branch
+        // Use URL constructor to prevent SSRF
+        const branchUrl = buildGitHubApiUrl(`/repos/${encodeURIComponent(repoIdStr)}/branches/main`);
+        const branchResponse = await fetch(
+          branchUrl.toString(),
+          {
+            headers: {
+              'Authorization': `Bearer ${token}`,
+              'Accept': 'application/vnd.github+json',
+              'X-GitHub-Api-Version': '2022-11-28',
+            },
+          }
+        );
+
+        if (!branchResponse.ok) {
+          if (branchResponse.status === 404) {
+            return {
+              repo_id,
+              state: 'unknown' as const,
+              total_checks: 0,
+              updated_at: new Date().toISOString(),
+              details: 'Main branch not found',
+            };
+          }
+          throw new Error(`GitHub API error: ${branchResponse.status}`);
+        }
+
+        const branchData = await branchResponse.json();
+        const latestCommitSha = branchData.commit.sha;
+
+        // Validate the commit SHA to prevent SSRF
+        if (!isValidCommitSha(latestCommitSha)) {
+          return {
+            repo_id,
+            state: 'unknown' as const,
+            total_checks: 0,
+            updated_at: new Date().toISOString(),
+            details: 'Invalid commit SHA received from API',
+          };
+        }
+
+        // Now get check runs for this specific commit
+        // Use URL constructor to prevent SSRF
+        const checksUrl = buildGitHubApiUrl(`/repos/${encodeURIComponent(repoIdStr)}/commits/${latestCommitSha}/check-runs`);
+        const checksResponse = await fetch(
+          checksUrl.toString(),
+          {
+            headers: {
+              'Authorization': `Bearer ${token}`,
+              'Accept': 'application/vnd.github+json',
+              'X-GitHub-Api-Version': '2022-11-28',
+            },
+          }
+        );
+
+        if (!checksResponse.ok) {
+          throw new Error(`GitHub API error: ${checksResponse.status}`);
+        }
+
+        const data = await checksResponse.json();
+        const checkRuns = data.check_runs || [];
+
+        if (checkRuns.length === 0) {
+          return {
+            repo_id,
+            state: 'unknown' as const,
+            total_checks: 0,
+            updated_at: new Date().toISOString(),
+            details: 'No CI configured',
+          };
+        }
+
+        // Check if any workflow runs failed
+        // Status: completed, in_progress, queued, waiting, requested, pending
+        // Conclusion (when completed): success, failure, neutral, cancelled, skipped, timed_out, action_required, startup_failure, stale
+        let hasFailure = false;
+        let hasPending = false;
+        let mostRecentUpdate = '';
+
+        for (const check of checkRuns) {
+          // Skip Dependabot checks - they mark as "failure" for dependency conflicts which aren't CI failures
+          if (check.app?.slug === 'dependabot' || check.name === 'Dependabot') {
+            continue;
+          }
+
+          // If the check hasn't completed yet, mark as pending
+          if (check.status !== 'completed') {
+            hasPending = true;
+          }
+          // If completed, check the conclusion
+          else if (check.conclusion === 'failure' ||
+                   check.conclusion === 'timed_out' ||
+                   check.conclusion === 'action_required' ||
+                   check.conclusion === 'startup_failure') {
+            hasFailure = true;
+          }
+
+          // Track most recent update
+          const updateTime = check.completed_at || check.started_at;
+          if (updateTime && (!mostRecentUpdate || updateTime > mostRecentUpdate)) {
+            mostRecentUpdate = updateTime;
+          }
+        }
+
+        // Determine overall state based on the checks
+        let state: 'success' | 'failure' | 'pending' | 'error' | 'unknown';
+        if (hasFailure) {
+          state = 'failure';
+        } else if (hasPending) {
+          state = 'pending';
+        } else {
+          // All checks completed without failure
+          state = 'success';
+        }
+
+        return {
+          repo_id,
+          state,
+          total_checks: checkRuns.length,
+          updated_at: mostRecentUpdate || new Date().toISOString(),
+          details: `${checkRuns.length} check(s)`,
+        };
+      } catch (error) {
+        console.error('Error fetching CI status for %s:', repo_id, error);
+        return {
+          repo_id,
+          state: 'unknown' as const,
+          total_checks: 0,
+          updated_at: new Date().toISOString(),
+          details: 'Error fetching status',
+        };
+      }
+    });
+
+    const results = await Promise.all(statusPromises);
+
+    // Convert array to object keyed by repo_id for easy lookup
+    const statusMap = results.reduce((acc, status) => {
+      acc[status.repo_id] = status;
+      return acc;
+    }, {} as Record<string, CIStatus>);
+
+    return NextResponse.json(statusMap);
+  } catch (error) {
+    console.error('CI status API error:', error);
+    return NextResponse.json(
+      { error: 'Failed to fetch CI statuses' },
+      { status: 500 }
+    );
+  }
+}
diff --git a/catalog-analytics/public/data/github_metrics_history.json b/catalog-analytics/public/data/github_metrics_history.json
index 9404be9..2bf88b9 100644
--- a/catalog-analytics/public/data/github_metrics_history.json
+++ b/catalog-analytics/public/data/github_metrics_history.json
@@ -182,6 +182,78 @@
           "created_at": "2025-06-13T13:37:34Z",
           "updated_at": "2025-12-02T22:11:24Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/midst-toolkit",
+          "name": "midst-toolkit",
+          "timestamp": "2025-12-08T12:03:03.498364+00:00",
+          "stars": 5,
+          "forks": 1,
+          "watchers": 0,
+          "open_issues": 3,
+          "size": 201266,
+          "views_14d": 765,
+          "unique_visitors_14d": 22,
+          "clones_14d": 735,
+          "unique_cloners_14d": 234,
+          "language": "Python",
+          "created_at": "2025-06-13T13:37:34Z",
+          "updated_at": "2025-12-02T22:11:24Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/midst-toolkit",
+          "name": "midst-toolkit",
+          "timestamp": "2025-12-15T12:03:22.651272+00:00",
+          "stars": 6,
+          "forks": 1,
+          "watchers": 0,
+          "open_issues": 6,
+          "size": 217228,
+          "views_14d": 812,
+          "unique_visitors_14d": 17,
+          "clones_14d": 729,
+          "unique_cloners_14d": 220,
+          "language": "Python",
+          "created_at": "2025-06-13T13:37:34Z",
+          "updated_at": "2025-12-12T16:35:40Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/midst-toolkit",
+          "name": "midst-toolkit",
+          "timestamp": "2025-12-22T12:03:06.051070+00:00",
+          "stars": 6,
+          "forks": 1,
+          "watchers": 0,
+          "open_issues": 1,
+          "size": 201289,
+          "views_14d": 647,
+          "unique_visitors_14d": 17,
+          "clones_14d": 395,
+          "unique_cloners_14d": 112,
+          "language": "Python",
+          "created_at": "2025-06-13T13:37:34Z",
+          "updated_at": "2025-12-17T19:50:32Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/midst-toolkit",
+          "name": "midst-toolkit",
+          "timestamp": "2025-12-23T15:53:03.695580+00:00",
+          "stars": 6,
+          "forks": 1,
+          "watchers": 0,
+          "open_issues": 1,
+          "size": 201289,
+          "views_14d": 594,
+          "unique_visitors_14d": 16,
+          "clones_14d": 346,
+          "unique_cloners_14d": 97,
+          "language": "Python",
+          "created_at": "2025-06-13T13:37:34Z",
+          "updated_at": "2025-12-17T19:50:32Z",
+          "topics": []
         }
       ]
     },
@@ -487,6 +559,126 @@
             "pytorch",
             "transformers"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/atomgen",
+          "name": "atomgen",
+          "timestamp": "2025-12-08T12:02:56.753970+00:00",
+          "stars": 8,
+          "forks": 1,
+          "watchers": 2,
+          "open_issues": 1,
+          "size": 2579,
+          "views_14d": 14,
+          "unique_visitors_14d": 7,
+          "clones_14d": 77,
+          "unique_cloners_14d": 39,
+          "language": "Python",
+          "created_at": "2024-04-11T01:22:34Z",
+          "updated_at": "2025-11-24T21:04:24Z",
+          "topics": [
+            "ai-for-science",
+            "atomistic-machine-learning",
+            "atomistic-models",
+            "atomistic-simulations",
+            "fine-tuning",
+            "huggingface",
+            "machine-learning",
+            "materials-science",
+            "pretrained-models",
+            "pytorch",
+            "transformers"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/atomgen",
+          "name": "atomgen",
+          "timestamp": "2025-12-15T12:03:13.793099+00:00",
+          "stars": 8,
+          "forks": 1,
+          "watchers": 2,
+          "open_issues": 4,
+          "size": 2594,
+          "views_14d": 9,
+          "unique_visitors_14d": 3,
+          "clones_14d": 65,
+          "unique_cloners_14d": 33,
+          "language": "Python",
+          "created_at": "2024-04-11T01:22:34Z",
+          "updated_at": "2025-12-08T17:30:06Z",
+          "topics": [
+            "ai-for-science",
+            "atomistic-machine-learning",
+            "atomistic-models",
+            "atomistic-simulations",
+            "fine-tuning",
+            "huggingface",
+            "machine-learning",
+            "materials-science",
+            "pretrained-models",
+            "pytorch",
+            "transformers"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/atomgen",
+          "name": "atomgen",
+          "timestamp": "2025-12-22T12:02:59.227543+00:00",
+          "stars": 8,
+          "forks": 1,
+          "watchers": 2,
+          "open_issues": 0,
+          "size": 2639,
+          "views_14d": 43,
+          "unique_visitors_14d": 5,
+          "clones_14d": 185,
+          "unique_cloners_14d": 77,
+          "language": "Python",
+          "created_at": "2024-04-11T01:22:34Z",
+          "updated_at": "2025-12-16T22:16:19Z",
+          "topics": [
+            "ai-for-science",
+            "atomistic-machine-learning",
+            "atomistic-models",
+            "atomistic-simulations",
+            "fine-tuning",
+            "huggingface",
+            "machine-learning",
+            "materials-science",
+            "pretrained-models",
+            "pytorch",
+            "transformers"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/atomgen",
+          "name": "atomgen",
+          "timestamp": "2025-12-23T15:52:58.655636+00:00",
+          "stars": 8,
+          "forks": 1,
+          "watchers": 2,
+          "open_issues": 2,
+          "size": 2790,
+          "views_14d": 35,
+          "unique_visitors_14d": 4,
+          "clones_14d": 162,
+          "unique_cloners_14d": 67,
+          "language": "Python",
+          "created_at": "2024-04-11T01:22:34Z",
+          "updated_at": "2025-12-16T22:16:19Z",
+          "topics": [
+            "ai-for-science",
+            "atomistic-machine-learning",
+            "atomistic-models",
+            "atomistic-simulations",
+            "fine-tuning",
+            "huggingface",
+            "machine-learning",
+            "materials-science",
+            "pretrained-models",
+            "pytorch",
+            "transformers"
+          ]
         }
       ]
     },
@@ -692,6 +884,86 @@
           "topics": [
             "anomaly-detection"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/anomaly-detection",
+          "name": "anomaly-detection",
+          "timestamp": "2025-12-08T12:03:04.181120+00:00",
+          "stars": 8,
+          "forks": 0,
+          "watchers": 19,
+          "open_issues": 0,
+          "size": 15604,
+          "views_14d": 30,
+          "unique_visitors_14d": 14,
+          "clones_14d": 2,
+          "unique_cloners_14d": 2,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-03-20T16:43:29Z",
+          "updated_at": "2025-07-29T21:42:49Z",
+          "topics": [
+            "anomaly-detection"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/anomaly-detection",
+          "name": "anomaly-detection",
+          "timestamp": "2025-12-15T12:03:23.523940+00:00",
+          "stars": 8,
+          "forks": 0,
+          "watchers": 19,
+          "open_issues": 0,
+          "size": 15604,
+          "views_14d": 28,
+          "unique_visitors_14d": 11,
+          "clones_14d": 3,
+          "unique_cloners_14d": 3,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-03-20T16:43:29Z",
+          "updated_at": "2025-07-29T21:42:49Z",
+          "topics": [
+            "anomaly-detection"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/anomaly-detection",
+          "name": "anomaly-detection",
+          "timestamp": "2025-12-22T12:03:06.762512+00:00",
+          "stars": 8,
+          "forks": 0,
+          "watchers": 19,
+          "open_issues": 0,
+          "size": 15604,
+          "views_14d": 39,
+          "unique_visitors_14d": 14,
+          "clones_14d": 4,
+          "unique_cloners_14d": 4,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-03-20T16:43:29Z",
+          "updated_at": "2025-07-29T21:42:49Z",
+          "topics": [
+            "anomaly-detection"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/anomaly-detection",
+          "name": "anomaly-detection",
+          "timestamp": "2025-12-23T15:53:19.356481+00:00",
+          "stars": 8,
+          "forks": 0,
+          "watchers": 19,
+          "open_issues": 0,
+          "size": 15604,
+          "views_14d": 39,
+          "unique_visitors_14d": 14,
+          "clones_14d": 5,
+          "unique_cloners_14d": 5,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-03-20T16:43:29Z",
+          "updated_at": "2025-07-29T21:42:49Z",
+          "topics": [
+            "anomaly-detection"
+          ]
         }
       ]
     },
@@ -1057,39 +1329,183 @@
             "omop-cdm",
             "physionet"
           ]
-        }
-      ]
-    },
-    "VectorInstitute/recommender-systems": {
-      "name": "recommender-systems",
-      "snapshots": [
-        {
-          "repo_id": "VectorInstitute/recommender-systems",
-          "name": "recommender-systems",
-          "timestamp": "2025-11-25T19:21:11.081524+00:00",
-          "stars": 6,
-          "forks": 0,
-          "watchers": 30,
-          "open_issues": 1,
-          "size": 27200,
-          "views_14d": 0,
-          "unique_visitors_14d": 0,
-          "clones_14d": 6,
-          "unique_cloners_14d": 6,
-          "language": "Jupyter Notebook",
-          "created_at": "2022-06-09T21:10:48Z",
-          "updated_at": "2025-05-13T20:17:43Z",
-          "topics": [
-            "recommender-system"
-          ]
         },
         {
-          "repo_id": "VectorInstitute/recommender-systems",
-          "name": "recommender-systems",
-          "timestamp": "2025-11-25T19:49:24.165457+00:00",
-          "stars": 6,
-          "forks": 0,
-          "watchers": 30,
+          "repo_id": "VectorInstitute/cyclops",
+          "name": "cyclops",
+          "timestamp": "2025-12-08T12:02:52.111928+00:00",
+          "stars": 87,
+          "forks": 14,
+          "watchers": 8,
+          "open_issues": 20,
+          "size": 27256,
+          "views_14d": 39,
+          "unique_visitors_14d": 24,
+          "clones_14d": 193,
+          "unique_cloners_14d": 133,
+          "language": "Python",
+          "created_at": "2022-02-21T21:15:08Z",
+          "updated_at": "2025-10-16T06:37:02Z",
+          "topics": [
+            "clinical-data",
+            "clinical-decision-support",
+            "clinical-research",
+            "data-drift",
+            "deep-learning",
+            "drift-detection",
+            "eicu-crd",
+            "electronic-health-record",
+            "electronic-medical-record",
+            "evaluation",
+            "healthcare",
+            "machine-learning",
+            "mimic-iii",
+            "mimic-iv",
+            "model-monitoring",
+            "omop-cdm",
+            "physionet"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/cyclops",
+          "name": "cyclops",
+          "timestamp": "2025-12-15T12:03:07.772451+00:00",
+          "stars": 87,
+          "forks": 14,
+          "watchers": 8,
+          "open_issues": 20,
+          "size": 27256,
+          "views_14d": 20,
+          "unique_visitors_14d": 17,
+          "clones_14d": 112,
+          "unique_cloners_14d": 43,
+          "language": "Python",
+          "created_at": "2022-02-21T21:15:08Z",
+          "updated_at": "2025-10-16T06:37:02Z",
+          "topics": [
+            "clinical-data",
+            "clinical-decision-support",
+            "clinical-research",
+            "data-drift",
+            "deep-learning",
+            "drift-detection",
+            "eicu-crd",
+            "electronic-health-record",
+            "electronic-medical-record",
+            "evaluation",
+            "healthcare",
+            "machine-learning",
+            "mimic-iii",
+            "mimic-iv",
+            "model-monitoring",
+            "omop-cdm",
+            "physionet"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/cyclops",
+          "name": "cyclops",
+          "timestamp": "2025-12-22T12:02:54.695987+00:00",
+          "stars": 87,
+          "forks": 14,
+          "watchers": 8,
+          "open_issues": 20,
+          "size": 27256,
+          "views_14d": 31,
+          "unique_visitors_14d": 24,
+          "clones_14d": 359,
+          "unique_cloners_14d": 69,
+          "language": "Python",
+          "created_at": "2022-02-21T21:15:08Z",
+          "updated_at": "2025-10-16T06:37:02Z",
+          "topics": [
+            "clinical-data",
+            "clinical-decision-support",
+            "clinical-research",
+            "data-drift",
+            "deep-learning",
+            "drift-detection",
+            "eicu-crd",
+            "electronic-health-record",
+            "electronic-medical-record",
+            "evaluation",
+            "healthcare",
+            "machine-learning",
+            "mimic-iii",
+            "mimic-iv",
+            "model-monitoring",
+            "omop-cdm",
+            "physionet"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/cyclops",
+          "name": "cyclops",
+          "timestamp": "2025-12-23T15:53:05.327997+00:00",
+          "stars": 87,
+          "forks": 14,
+          "watchers": 8,
+          "open_issues": 20,
+          "size": 27256,
+          "views_14d": 31,
+          "unique_visitors_14d": 24,
+          "clones_14d": 355,
+          "unique_cloners_14d": 70,
+          "language": "Python",
+          "created_at": "2022-02-21T21:15:08Z",
+          "updated_at": "2025-10-16T06:37:02Z",
+          "topics": [
+            "clinical-data",
+            "clinical-decision-support",
+            "clinical-research",
+            "data-drift",
+            "deep-learning",
+            "drift-detection",
+            "eicu-crd",
+            "electronic-health-record",
+            "electronic-medical-record",
+            "evaluation",
+            "healthcare",
+            "machine-learning",
+            "mimic-iii",
+            "mimic-iv",
+            "model-monitoring",
+            "omop-cdm",
+            "physionet"
+          ]
+        }
+      ]
+    },
+    "VectorInstitute/recommender-systems": {
+      "name": "recommender-systems",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/recommender-systems",
+          "name": "recommender-systems",
+          "timestamp": "2025-11-25T19:21:11.081524+00:00",
+          "stars": 6,
+          "forks": 0,
+          "watchers": 30,
+          "open_issues": 1,
+          "size": 27200,
+          "views_14d": 0,
+          "unique_visitors_14d": 0,
+          "clones_14d": 6,
+          "unique_cloners_14d": 6,
+          "language": "Jupyter Notebook",
+          "created_at": "2022-06-09T21:10:48Z",
+          "updated_at": "2025-05-13T20:17:43Z",
+          "topics": [
+            "recommender-system"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/recommender-systems",
+          "name": "recommender-systems",
+          "timestamp": "2025-11-25T19:49:24.165457+00:00",
+          "stars": 6,
+          "forks": 0,
+          "watchers": 30,
           "open_issues": 1,
           "size": 27200,
           "views_14d": 0,
@@ -1262,6 +1678,86 @@
           "topics": [
             "recommender-system"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/recommender-systems",
+          "name": "recommender-systems",
+          "timestamp": "2025-12-08T12:02:50.183423+00:00",
+          "stars": 6,
+          "forks": 0,
+          "watchers": 30,
+          "open_issues": 1,
+          "size": 27200,
+          "views_14d": 0,
+          "unique_visitors_14d": 0,
+          "clones_14d": 3,
+          "unique_cloners_14d": 2,
+          "language": "Jupyter Notebook",
+          "created_at": "2022-06-09T21:10:48Z",
+          "updated_at": "2025-05-13T20:17:43Z",
+          "topics": [
+            "recommender-system"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/recommender-systems",
+          "name": "recommender-systems",
+          "timestamp": "2025-12-15T12:03:05.346785+00:00",
+          "stars": 6,
+          "forks": 0,
+          "watchers": 30,
+          "open_issues": 1,
+          "size": 27200,
+          "views_14d": 0,
+          "unique_visitors_14d": 0,
+          "clones_14d": 4,
+          "unique_cloners_14d": 4,
+          "language": "Jupyter Notebook",
+          "created_at": "2022-06-09T21:10:48Z",
+          "updated_at": "2025-05-13T20:17:43Z",
+          "topics": [
+            "recommender-system"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/recommender-systems",
+          "name": "recommender-systems",
+          "timestamp": "2025-12-22T12:02:52.752056+00:00",
+          "stars": 6,
+          "forks": 0,
+          "watchers": 30,
+          "open_issues": 1,
+          "size": 27200,
+          "views_14d": 0,
+          "unique_visitors_14d": 0,
+          "clones_14d": 5,
+          "unique_cloners_14d": 5,
+          "language": "Jupyter Notebook",
+          "created_at": "2022-06-09T21:10:48Z",
+          "updated_at": "2025-05-13T20:17:43Z",
+          "topics": [
+            "recommender-system"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/recommender-systems",
+          "name": "recommender-systems",
+          "timestamp": "2025-12-23T15:52:51.296878+00:00",
+          "stars": 6,
+          "forks": 0,
+          "watchers": 30,
+          "open_issues": 1,
+          "size": 27200,
+          "views_14d": 0,
+          "unique_visitors_14d": 0,
+          "clones_14d": 6,
+          "unique_cloners_14d": 6,
+          "language": "Jupyter Notebook",
+          "created_at": "2022-06-09T21:10:48Z",
+          "updated_at": "2025-05-13T20:17:43Z",
+          "topics": [
+            "recommender-system"
+          ]
         }
       ]
     },
@@ -1507,27 +2003,123 @@
             "machine-learning",
             "rag"
           ]
-        }
-      ]
-    },
-    "VectorInstitute/odyssey": {
-      "name": "odyssey",
-      "snapshots": [
+        },
         {
-          "repo_id": "VectorInstitute/odyssey",
-          "name": "odyssey",
-          "timestamp": "2025-11-25T19:21:13.219775+00:00",
-          "stars": 45,
-          "forks": 13,
-          "watchers": 4,
-          "open_issues": 8,
-          "size": 106582,
-          "views_14d": 278,
-          "unique_visitors_14d": 39,
-          "clones_14d": 86,
-          "unique_cloners_14d": 42,
-          "language": "Python",
-          "created_at": "2023-12-01T15:46:32Z",
+          "repo_id": "VectorInstitute/fed-rag",
+          "name": "fed-rag",
+          "timestamp": "2025-12-08T12:03:02.873631+00:00",
+          "stars": 137,
+          "forks": 26,
+          "watchers": 6,
+          "open_issues": 50,
+          "size": 14153,
+          "views_14d": 218,
+          "unique_visitors_14d": 68,
+          "clones_14d": 155,
+          "unique_cloners_14d": 96,
+          "language": "Python",
+          "created_at": "2025-01-17T20:04:22Z",
+          "updated_at": "2025-11-26T21:02:01Z",
+          "topics": [
+            "deep-learning",
+            "federated-learning",
+            "llms",
+            "machine-learning",
+            "rag"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/fed-rag",
+          "name": "fed-rag",
+          "timestamp": "2025-12-15T12:03:21.914111+00:00",
+          "stars": 137,
+          "forks": 26,
+          "watchers": 6,
+          "open_issues": 52,
+          "size": 14196,
+          "views_14d": 161,
+          "unique_visitors_14d": 57,
+          "clones_14d": 185,
+          "unique_cloners_14d": 56,
+          "language": "Python",
+          "created_at": "2025-01-17T20:04:22Z",
+          "updated_at": "2025-11-26T21:02:01Z",
+          "topics": [
+            "deep-learning",
+            "federated-learning",
+            "llms",
+            "machine-learning",
+            "rag"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/fed-rag",
+          "name": "fed-rag",
+          "timestamp": "2025-12-22T12:03:05.347010+00:00",
+          "stars": 137,
+          "forks": 26,
+          "watchers": 6,
+          "open_issues": 51,
+          "size": 14216,
+          "views_14d": 112,
+          "unique_visitors_14d": 49,
+          "clones_14d": 306,
+          "unique_cloners_14d": 85,
+          "language": "Python",
+          "created_at": "2025-01-17T20:04:22Z",
+          "updated_at": "2025-12-19T23:21:22Z",
+          "topics": [
+            "deep-learning",
+            "federated-learning",
+            "llms",
+            "machine-learning",
+            "rag"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/fed-rag",
+          "name": "fed-rag",
+          "timestamp": "2025-12-23T15:53:17.399437+00:00",
+          "stars": 137,
+          "forks": 26,
+          "watchers": 6,
+          "open_issues": 51,
+          "size": 14216,
+          "views_14d": 140,
+          "unique_visitors_14d": 49,
+          "clones_14d": 299,
+          "unique_cloners_14d": 86,
+          "language": "Python",
+          "created_at": "2025-01-17T20:04:22Z",
+          "updated_at": "2025-12-19T23:21:22Z",
+          "topics": [
+            "deep-learning",
+            "federated-learning",
+            "llms",
+            "machine-learning",
+            "rag"
+          ]
+        }
+      ]
+    },
+    "VectorInstitute/odyssey": {
+      "name": "odyssey",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/odyssey",
+          "name": "odyssey",
+          "timestamp": "2025-11-25T19:21:13.219775+00:00",
+          "stars": 45,
+          "forks": 13,
+          "watchers": 4,
+          "open_issues": 8,
+          "size": 106582,
+          "views_14d": 278,
+          "unique_visitors_14d": 39,
+          "clones_14d": 86,
+          "unique_cloners_14d": 42,
+          "language": "Python",
+          "created_at": "2023-12-01T15:46:32Z",
           "updated_at": "2025-11-24T21:29:10Z",
           "topics": [
             "electronic-health-record",
@@ -1772,6 +2364,110 @@
             "state-space-models",
             "transformers"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/odyssey",
+          "name": "odyssey",
+          "timestamp": "2025-12-08T12:02:54.133658+00:00",
+          "stars": 46,
+          "forks": 14,
+          "watchers": 4,
+          "open_issues": 9,
+          "size": 105571,
+          "views_14d": 395,
+          "unique_visitors_14d": 32,
+          "clones_14d": 123,
+          "unique_cloners_14d": 61,
+          "language": "Python",
+          "created_at": "2023-12-01T15:46:32Z",
+          "updated_at": "2025-12-05T17:10:54Z",
+          "topics": [
+            "electronic-health-record",
+            "foundation-models",
+            "healthcare",
+            "machine-learning",
+            "mimic-iv",
+            "state-space-models",
+            "transformers"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/odyssey",
+          "name": "odyssey",
+          "timestamp": "2025-12-15T12:03:10.166787+00:00",
+          "stars": 46,
+          "forks": 14,
+          "watchers": 4,
+          "open_issues": 8,
+          "size": 105586,
+          "views_14d": 288,
+          "unique_visitors_14d": 42,
+          "clones_14d": 149,
+          "unique_cloners_14d": 74,
+          "language": "Python",
+          "created_at": "2023-12-01T15:46:32Z",
+          "updated_at": "2025-12-08T20:27:06Z",
+          "topics": [
+            "electronic-health-record",
+            "foundation-models",
+            "healthcare",
+            "machine-learning",
+            "mimic-iv",
+            "state-space-models",
+            "transformers"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/odyssey",
+          "name": "odyssey",
+          "timestamp": "2025-12-22T12:02:56.694446+00:00",
+          "stars": 48,
+          "forks": 14,
+          "watchers": 4,
+          "open_issues": 9,
+          "size": 105588,
+          "views_14d": 219,
+          "unique_visitors_14d": 47,
+          "clones_14d": 107,
+          "unique_cloners_14d": 57,
+          "language": "Python",
+          "created_at": "2023-12-01T15:46:32Z",
+          "updated_at": "2025-12-19T10:03:46Z",
+          "topics": [
+            "electronic-health-record",
+            "foundation-models",
+            "healthcare",
+            "machine-learning",
+            "mimic-iv",
+            "state-space-models",
+            "transformers"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/odyssey",
+          "name": "odyssey",
+          "timestamp": "2025-12-23T15:53:23.431146+00:00",
+          "stars": 48,
+          "forks": 14,
+          "watchers": 4,
+          "open_issues": 9,
+          "size": 105588,
+          "views_14d": 190,
+          "unique_visitors_14d": 48,
+          "clones_14d": 57,
+          "unique_cloners_14d": 32,
+          "language": "Python",
+          "created_at": "2023-12-01T15:46:32Z",
+          "updated_at": "2025-12-19T10:03:46Z",
+          "topics": [
+            "electronic-health-record",
+            "foundation-models",
+            "healthcare",
+            "machine-learning",
+            "mimic-iv",
+            "state-space-models",
+            "transformers"
+          ]
         }
       ]
     },
@@ -2027,67 +2723,167 @@
             "quilt",
             "shared-encoder"
           ]
-        }
-      ]
-    },
-    "VectorInstitute/privacy-enhancing-techniques": {
-      "name": "privacy-enhancing-techniques",
-      "snapshots": [
+        },
         {
-          "repo_id": "VectorInstitute/privacy-enhancing-techniques",
-          "name": "privacy-enhancing-techniques",
-          "timestamp": "2025-11-25T19:21:15.284695+00:00",
-          "stars": 15,
-          "forks": 9,
-          "watchers": 16,
-          "open_issues": 0,
-          "size": 35253,
-          "views_14d": 3,
-          "unique_visitors_14d": 2,
-          "clones_14d": 3,
-          "unique_cloners_14d": 3,
-          "language": "Jupyter Notebook",
-          "created_at": "2021-09-28T17:43:56Z",
-          "updated_at": "2025-07-30T00:00:30Z",
+          "repo_id": "VectorInstitute/shared-encoder",
+          "name": "shared-encoder",
+          "timestamp": "2025-12-08T12:03:00.239160+00:00",
+          "stars": 9,
+          "forks": 1,
+          "watchers": 4,
+          "open_issues": 3,
+          "size": 157,
+          "views_14d": 10,
+          "unique_visitors_14d": 10,
+          "clones_14d": 9,
+          "unique_cloners_14d": 9,
+          "language": "Python",
+          "created_at": "2025-02-21T17:04:07Z",
+          "updated_at": "2025-10-02T02:00:56Z",
           "topics": [
-            "differential-privacy",
-            "encryption",
-            "federated-learning",
-            "machine-learning",
-            "ml",
-            "privacy"
+            "clip",
+            "mimic-cxr",
+            "multimodal",
+            "multimodal-learning",
+            "quilt",
+            "shared-encoder"
           ]
         },
         {
-          "repo_id": "VectorInstitute/privacy-enhancing-techniques",
-          "name": "privacy-enhancing-techniques",
-          "timestamp": "2025-11-25T19:49:28.009115+00:00",
-          "stars": 15,
-          "forks": 9,
-          "watchers": 16,
-          "open_issues": 0,
-          "size": 35253,
-          "views_14d": 3,
-          "unique_visitors_14d": 2,
+          "repo_id": "VectorInstitute/shared-encoder",
+          "name": "shared-encoder",
+          "timestamp": "2025-12-15T12:03:18.609059+00:00",
+          "stars": 9,
+          "forks": 1,
+          "watchers": 4,
+          "open_issues": 3,
+          "size": 157,
+          "views_14d": 13,
+          "unique_visitors_14d": 11,
           "clones_14d": 3,
           "unique_cloners_14d": 3,
-          "language": "Jupyter Notebook",
-          "created_at": "2021-09-28T17:43:56Z",
-          "updated_at": "2025-07-30T00:00:30Z",
+          "language": "Python",
+          "created_at": "2025-02-21T17:04:07Z",
+          "updated_at": "2025-10-02T02:00:56Z",
           "topics": [
-            "differential-privacy",
-            "encryption",
-            "federated-learning",
-            "machine-learning",
-            "ml",
-            "privacy"
+            "clip",
+            "mimic-cxr",
+            "multimodal",
+            "multimodal-learning",
+            "quilt",
+            "shared-encoder"
           ]
         },
         {
-          "repo_id": "VectorInstitute/privacy-enhancing-techniques",
-          "name": "privacy-enhancing-techniques",
-          "timestamp": "2025-11-25T20:04:51.634263+00:00",
-          "stars": 15,
+          "repo_id": "VectorInstitute/shared-encoder",
+          "name": "shared-encoder",
+          "timestamp": "2025-12-22T12:03:02.718752+00:00",
+          "stars": 9,
+          "forks": 1,
+          "watchers": 4,
+          "open_issues": 3,
+          "size": 157,
+          "views_14d": 9,
+          "unique_visitors_14d": 7,
+          "clones_14d": 10,
+          "unique_cloners_14d": 9,
+          "language": "Python",
+          "created_at": "2025-02-21T17:04:07Z",
+          "updated_at": "2025-10-02T02:00:56Z",
+          "topics": [
+            "clip",
+            "mimic-cxr",
+            "multimodal",
+            "multimodal-learning",
+            "quilt",
+            "shared-encoder"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/shared-encoder",
+          "name": "shared-encoder",
+          "timestamp": "2025-12-23T15:53:14.410096+00:00",
+          "stars": 9,
+          "forks": 1,
+          "watchers": 4,
+          "open_issues": 3,
+          "size": 157,
+          "views_14d": 9,
+          "unique_visitors_14d": 7,
+          "clones_14d": 11,
+          "unique_cloners_14d": 10,
+          "language": "Python",
+          "created_at": "2025-02-21T17:04:07Z",
+          "updated_at": "2025-10-02T02:00:56Z",
+          "topics": [
+            "clip",
+            "mimic-cxr",
+            "multimodal",
+            "multimodal-learning",
+            "quilt",
+            "shared-encoder"
+          ]
+        }
+      ]
+    },
+    "VectorInstitute/privacy-enhancing-techniques": {
+      "name": "privacy-enhancing-techniques",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/privacy-enhancing-techniques",
+          "name": "privacy-enhancing-techniques",
+          "timestamp": "2025-11-25T19:21:15.284695+00:00",
+          "stars": 15,
+          "forks": 9,
+          "watchers": 16,
+          "open_issues": 0,
+          "size": 35253,
+          "views_14d": 3,
+          "unique_visitors_14d": 2,
+          "clones_14d": 3,
+          "unique_cloners_14d": 3,
+          "language": "Jupyter Notebook",
+          "created_at": "2021-09-28T17:43:56Z",
+          "updated_at": "2025-07-30T00:00:30Z",
+          "topics": [
+            "differential-privacy",
+            "encryption",
+            "federated-learning",
+            "machine-learning",
+            "ml",
+            "privacy"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/privacy-enhancing-techniques",
+          "name": "privacy-enhancing-techniques",
+          "timestamp": "2025-11-25T19:49:28.009115+00:00",
+          "stars": 15,
+          "forks": 9,
+          "watchers": 16,
+          "open_issues": 0,
+          "size": 35253,
+          "views_14d": 3,
+          "unique_visitors_14d": 2,
+          "clones_14d": 3,
+          "unique_cloners_14d": 3,
+          "language": "Jupyter Notebook",
+          "created_at": "2021-09-28T17:43:56Z",
+          "updated_at": "2025-07-30T00:00:30Z",
+          "topics": [
+            "differential-privacy",
+            "encryption",
+            "federated-learning",
+            "machine-learning",
+            "ml",
+            "privacy"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/privacy-enhancing-techniques",
+          "name": "privacy-enhancing-techniques",
+          "timestamp": "2025-11-25T20:04:51.634263+00:00",
+          "stars": 15,
           "forks": 9,
           "watchers": 16,
           "open_issues": 0,
@@ -2282,6 +3078,106 @@
             "ml",
             "privacy"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/privacy-enhancing-techniques",
+          "name": "privacy-enhancing-techniques",
+          "timestamp": "2025-12-08T12:02:58.075094+00:00",
+          "stars": 15,
+          "forks": 9,
+          "watchers": 16,
+          "open_issues": 0,
+          "size": 35253,
+          "views_14d": 2,
+          "unique_visitors_14d": 2,
+          "clones_14d": 7,
+          "unique_cloners_14d": 5,
+          "language": "Jupyter Notebook",
+          "created_at": "2021-09-28T17:43:56Z",
+          "updated_at": "2025-07-30T00:00:30Z",
+          "topics": [
+            "differential-privacy",
+            "encryption",
+            "federated-learning",
+            "machine-learning",
+            "ml",
+            "privacy"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/privacy-enhancing-techniques",
+          "name": "privacy-enhancing-techniques",
+          "timestamp": "2025-12-15T12:03:15.290333+00:00",
+          "stars": 15,
+          "forks": 9,
+          "watchers": 16,
+          "open_issues": 0,
+          "size": 35253,
+          "views_14d": 0,
+          "unique_visitors_14d": 0,
+          "clones_14d": 3,
+          "unique_cloners_14d": 3,
+          "language": "Jupyter Notebook",
+          "created_at": "2021-09-28T17:43:56Z",
+          "updated_at": "2025-07-30T00:00:30Z",
+          "topics": [
+            "differential-privacy",
+            "encryption",
+            "federated-learning",
+            "machine-learning",
+            "ml",
+            "privacy"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/privacy-enhancing-techniques",
+          "name": "privacy-enhancing-techniques",
+          "timestamp": "2025-12-22T12:03:00.637356+00:00",
+          "stars": 15,
+          "forks": 9,
+          "watchers": 16,
+          "open_issues": 0,
+          "size": 35253,
+          "views_14d": 0,
+          "unique_visitors_14d": 0,
+          "clones_14d": 8,
+          "unique_cloners_14d": 8,
+          "language": "Jupyter Notebook",
+          "created_at": "2021-09-28T17:43:56Z",
+          "updated_at": "2025-07-30T00:00:30Z",
+          "topics": [
+            "differential-privacy",
+            "encryption",
+            "federated-learning",
+            "machine-learning",
+            "ml",
+            "privacy"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/privacy-enhancing-techniques",
+          "name": "privacy-enhancing-techniques",
+          "timestamp": "2025-12-23T15:52:59.651775+00:00",
+          "stars": 15,
+          "forks": 9,
+          "watchers": 16,
+          "open_issues": 0,
+          "size": 35253,
+          "views_14d": 0,
+          "unique_visitors_14d": 0,
+          "clones_14d": 7,
+          "unique_cloners_14d": 7,
+          "language": "Jupyter Notebook",
+          "created_at": "2021-09-28T17:43:56Z",
+          "updated_at": "2025-07-30T00:00:30Z",
+          "topics": [
+            "differential-privacy",
+            "encryption",
+            "federated-learning",
+            "machine-learning",
+            "ml",
+            "privacy"
+          ]
         }
       ]
     },
@@ -2517,43 +3413,135 @@
             "self-distillation",
             "self-supervised-learning"
           ]
-        }
-      ]
-    },
-    "VectorInstitute/FLorist": {
-      "name": "FLorist",
-      "snapshots": [
+        },
         {
-          "repo_id": "VectorInstitute/FLorist",
-          "name": "FLorist",
-          "timestamp": "2025-11-25T19:21:17.446281+00:00",
-          "stars": 10,
-          "forks": 1,
-          "watchers": 4,
-          "open_issues": 1,
-          "size": 5429,
-          "views_14d": 0,
-          "unique_visitors_14d": 0,
-          "clones_14d": 126,
-          "unique_cloners_14d": 47,
-          "language": "CSS",
-          "created_at": "2024-01-29T19:34:13Z",
-          "updated_at": "2025-11-24T20:31:52Z",
-          "topics": []
+          "repo_id": "VectorInstitute/self-supervised-learning",
+          "name": "self-supervised-learning",
+          "timestamp": "2025-12-08T12:03:02.236600+00:00",
+          "stars": 3,
+          "forks": 0,
+          "watchers": 18,
+          "open_issues": 0,
+          "size": 84026,
+          "views_14d": 7,
+          "unique_visitors_14d": 3,
+          "clones_14d": 5,
+          "unique_cloners_14d": 5,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-08-17T15:25:42Z",
+          "updated_at": "2025-11-26T21:28:48Z",
+          "topics": [
+            "contrastive-learning",
+            "masked-modelling",
+            "self-distillation",
+            "self-supervised-learning"
+          ]
         },
         {
-          "repo_id": "VectorInstitute/FLorist",
-          "name": "FLorist",
-          "timestamp": "2025-11-25T19:49:29.910630+00:00",
-          "stars": 10,
-          "forks": 1,
-          "watchers": 4,
-          "open_issues": 1,
-          "size": 5429,
-          "views_14d": 0,
-          "unique_visitors_14d": 0,
-          "clones_14d": 126,
-          "unique_cloners_14d": 47,
+          "repo_id": "VectorInstitute/self-supervised-learning",
+          "name": "self-supervised-learning",
+          "timestamp": "2025-12-15T12:03:21.068966+00:00",
+          "stars": 3,
+          "forks": 0,
+          "watchers": 18,
+          "open_issues": 0,
+          "size": 84026,
+          "views_14d": 4,
+          "unique_visitors_14d": 4,
+          "clones_14d": 4,
+          "unique_cloners_14d": 4,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-08-17T15:25:42Z",
+          "updated_at": "2025-11-26T21:28:48Z",
+          "topics": [
+            "contrastive-learning",
+            "masked-modelling",
+            "self-distillation",
+            "self-supervised-learning"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/self-supervised-learning",
+          "name": "self-supervised-learning",
+          "timestamp": "2025-12-22T12:03:04.608234+00:00",
+          "stars": 3,
+          "forks": 0,
+          "watchers": 18,
+          "open_issues": 0,
+          "size": 84026,
+          "views_14d": 3,
+          "unique_visitors_14d": 3,
+          "clones_14d": 3,
+          "unique_cloners_14d": 3,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-08-17T15:25:42Z",
+          "updated_at": "2025-11-26T21:28:48Z",
+          "topics": [
+            "contrastive-learning",
+            "masked-modelling",
+            "self-distillation",
+            "self-supervised-learning"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/self-supervised-learning",
+          "name": "self-supervised-learning",
+          "timestamp": "2025-12-23T15:52:55.204482+00:00",
+          "stars": 3,
+          "forks": 0,
+          "watchers": 18,
+          "open_issues": 0,
+          "size": 84026,
+          "views_14d": 3,
+          "unique_visitors_14d": 3,
+          "clones_14d": 3,
+          "unique_cloners_14d": 3,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-08-17T15:25:42Z",
+          "updated_at": "2025-11-26T21:28:48Z",
+          "topics": [
+            "contrastive-learning",
+            "masked-modelling",
+            "self-distillation",
+            "self-supervised-learning"
+          ]
+        }
+      ]
+    },
+    "VectorInstitute/FLorist": {
+      "name": "FLorist",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/FLorist",
+          "name": "FLorist",
+          "timestamp": "2025-11-25T19:21:17.446281+00:00",
+          "stars": 10,
+          "forks": 1,
+          "watchers": 4,
+          "open_issues": 1,
+          "size": 5429,
+          "views_14d": 0,
+          "unique_visitors_14d": 0,
+          "clones_14d": 126,
+          "unique_cloners_14d": 47,
+          "language": "CSS",
+          "created_at": "2024-01-29T19:34:13Z",
+          "updated_at": "2025-11-24T20:31:52Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/FLorist",
+          "name": "FLorist",
+          "timestamp": "2025-11-25T19:49:29.910630+00:00",
+          "stars": 10,
+          "forks": 1,
+          "watchers": 4,
+          "open_issues": 1,
+          "size": 5429,
+          "views_14d": 0,
+          "unique_visitors_14d": 0,
+          "clones_14d": 126,
+          "unique_cloners_14d": 47,
           "language": "CSS",
           "created_at": "2024-01-29T19:34:13Z",
           "updated_at": "2025-11-24T20:31:52Z",
@@ -2702,6 +3690,78 @@
           "created_at": "2024-01-29T19:34:13Z",
           "updated_at": "2025-12-01T20:59:07Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/FLorist",
+          "name": "FLorist",
+          "timestamp": "2025-12-08T12:02:57.441641+00:00",
+          "stars": 10,
+          "forks": 1,
+          "watchers": 4,
+          "open_issues": 3,
+          "size": 5629,
+          "views_14d": 22,
+          "unique_visitors_14d": 10,
+          "clones_14d": 279,
+          "unique_cloners_14d": 121,
+          "language": "CSS",
+          "created_at": "2024-01-29T19:34:13Z",
+          "updated_at": "2025-12-03T21:18:32Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/FLorist",
+          "name": "FLorist",
+          "timestamp": "2025-12-15T12:03:14.587092+00:00",
+          "stars": 10,
+          "forks": 1,
+          "watchers": 4,
+          "open_issues": 2,
+          "size": 5829,
+          "views_14d": 18,
+          "unique_visitors_14d": 6,
+          "clones_14d": 302,
+          "unique_cloners_14d": 122,
+          "language": "CSS",
+          "created_at": "2024-01-29T19:34:13Z",
+          "updated_at": "2025-12-12T17:31:17Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/FLorist",
+          "name": "FLorist",
+          "timestamp": "2025-12-22T12:02:59.941858+00:00",
+          "stars": 10,
+          "forks": 1,
+          "watchers": 4,
+          "open_issues": 2,
+          "size": 6064,
+          "views_14d": 2,
+          "unique_visitors_14d": 2,
+          "clones_14d": 212,
+          "unique_cloners_14d": 85,
+          "language": "CSS",
+          "created_at": "2024-01-29T19:34:13Z",
+          "updated_at": "2025-12-15T20:01:16Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/FLorist",
+          "name": "FLorist",
+          "timestamp": "2025-12-23T15:53:12.385215+00:00",
+          "stars": 10,
+          "forks": 1,
+          "watchers": 4,
+          "open_issues": 2,
+          "size": 6069,
+          "views_14d": 2,
+          "unique_visitors_14d": 2,
+          "clones_14d": 234,
+          "unique_cloners_14d": 92,
+          "language": "CSS",
+          "created_at": "2024-01-29T19:34:13Z",
+          "updated_at": "2025-12-22T20:06:52Z",
+          "topics": []
         }
       ]
     },
@@ -2887,6 +3947,78 @@
           "created_at": "2025-11-21T16:57:41Z",
           "updated_at": "2025-11-26T21:34:25Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/bias-in-the-picture-benchmark",
+          "name": "bias-in-the-picture-benchmark",
+          "timestamp": "2025-12-08T12:02:48.149363+00:00",
+          "stars": 3,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 9705,
+          "views_14d": 32,
+          "unique_visitors_14d": 10,
+          "clones_14d": 3,
+          "unique_cloners_14d": 3,
+          "language": "Python",
+          "created_at": "2025-11-21T16:57:41Z",
+          "updated_at": "2025-11-26T21:34:25Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/bias-in-the-picture-benchmark",
+          "name": "bias-in-the-picture-benchmark",
+          "timestamp": "2025-12-15T12:03:02.922369+00:00",
+          "stars": 3,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 9705,
+          "views_14d": 23,
+          "unique_visitors_14d": 9,
+          "clones_14d": 3,
+          "unique_cloners_14d": 3,
+          "language": "Python",
+          "created_at": "2025-11-21T16:57:41Z",
+          "updated_at": "2025-11-26T21:34:25Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/bias-in-the-picture-benchmark",
+          "name": "bias-in-the-picture-benchmark",
+          "timestamp": "2025-12-22T12:02:50.647704+00:00",
+          "stars": 3,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 9705,
+          "views_14d": 4,
+          "unique_visitors_14d": 4,
+          "clones_14d": 4,
+          "unique_cloners_14d": 4,
+          "language": "Python",
+          "created_at": "2025-11-21T16:57:41Z",
+          "updated_at": "2025-11-26T21:34:25Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/bias-in-the-picture-benchmark",
+          "name": "bias-in-the-picture-benchmark",
+          "timestamp": "2025-12-23T15:53:01.720803+00:00",
+          "stars": 3,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 9705,
+          "views_14d": 3,
+          "unique_visitors_14d": 3,
+          "clones_14d": 4,
+          "unique_cloners_14d": 4,
+          "language": "Python",
+          "created_at": "2025-11-21T16:57:41Z",
+          "updated_at": "2025-11-26T21:34:25Z",
+          "topics": []
         }
       ]
     },
@@ -3112,29 +4244,117 @@
             "llms",
             "rag"
           ]
-        }
-      ]
-    },
-    "VectorInstitute/interpretability": {
-      "name": "interpretability",
-      "snapshots": [
+        },
         {
-          "repo_id": "VectorInstitute/interpretability",
-          "name": "interpretability",
-          "timestamp": "2025-11-25T19:21:20.843819+00:00",
-          "stars": 5,
-          "forks": 0,
-          "watchers": 7,
-          "open_issues": 0,
-          "size": 547693,
-          "views_14d": 48,
-          "unique_visitors_14d": 6,
-          "clones_14d": 2,
-          "unique_cloners_14d": 2,
-          "language": "Jupyter Notebook",
-          "created_at": "2024-09-19T15:22:45Z",
-          "updated_at": "2025-09-17T16:25:22Z",
-          "topics": []
+          "repo_id": "VectorInstitute/kg-rag",
+          "name": "kg-rag",
+          "timestamp": "2025-12-08T12:02:49.421581+00:00",
+          "stars": 20,
+          "forks": 10,
+          "watchers": 2,
+          "open_issues": 1,
+          "size": 44514,
+          "views_14d": 187,
+          "unique_visitors_14d": 74,
+          "clones_14d": 146,
+          "unique_cloners_14d": 72,
+          "language": "Python",
+          "created_at": "2024-12-11T17:22:56Z",
+          "updated_at": "2025-12-03T15:53:36Z",
+          "topics": [
+            "knowledge-graph",
+            "llms",
+            "rag"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/kg-rag",
+          "name": "kg-rag",
+          "timestamp": "2025-12-15T12:03:04.498353+00:00",
+          "stars": 21,
+          "forks": 10,
+          "watchers": 2,
+          "open_issues": 2,
+          "size": 44517,
+          "views_14d": 194,
+          "unique_visitors_14d": 71,
+          "clones_14d": 135,
+          "unique_cloners_14d": 68,
+          "language": "Python",
+          "created_at": "2024-12-11T17:22:56Z",
+          "updated_at": "2025-12-13T00:53:50Z",
+          "topics": [
+            "knowledge-graph",
+            "llms",
+            "rag"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/kg-rag",
+          "name": "kg-rag",
+          "timestamp": "2025-12-22T12:02:51.919317+00:00",
+          "stars": 21,
+          "forks": 10,
+          "watchers": 2,
+          "open_issues": 1,
+          "size": 44565,
+          "views_14d": 445,
+          "unique_visitors_14d": 72,
+          "clones_14d": 116,
+          "unique_cloners_14d": 60,
+          "language": "Python",
+          "created_at": "2024-12-11T17:22:56Z",
+          "updated_at": "2025-12-18T04:20:12Z",
+          "topics": [
+            "knowledge-graph",
+            "llms",
+            "rag"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/kg-rag",
+          "name": "kg-rag",
+          "timestamp": "2025-12-23T15:53:10.317199+00:00",
+          "stars": 22,
+          "forks": 10,
+          "watchers": 2,
+          "open_issues": 1,
+          "size": 44565,
+          "views_14d": 448,
+          "unique_visitors_14d": 69,
+          "clones_14d": 118,
+          "unique_cloners_14d": 59,
+          "language": "Python",
+          "created_at": "2024-12-11T17:22:56Z",
+          "updated_at": "2025-12-22T12:07:19Z",
+          "topics": [
+            "knowledge-graph",
+            "llms",
+            "rag"
+          ]
+        }
+      ]
+    },
+    "VectorInstitute/interpretability": {
+      "name": "interpretability",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/interpretability",
+          "name": "interpretability",
+          "timestamp": "2025-11-25T19:21:20.843819+00:00",
+          "stars": 5,
+          "forks": 0,
+          "watchers": 7,
+          "open_issues": 0,
+          "size": 547693,
+          "views_14d": 48,
+          "unique_visitors_14d": 6,
+          "clones_14d": 2,
+          "unique_cloners_14d": 2,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-09-19T15:22:45Z",
+          "updated_at": "2025-09-17T16:25:22Z",
+          "topics": []
         },
         {
           "repo_id": "VectorInstitute/interpretability",
@@ -3317,6 +4537,94 @@
             "interpretability",
             "machine-learning"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/interpretability",
+          "name": "interpretability",
+          "timestamp": "2025-12-08T12:03:01.516539+00:00",
+          "stars": 5,
+          "forks": 0,
+          "watchers": 7,
+          "open_issues": 0,
+          "size": 552929,
+          "views_14d": 122,
+          "unique_visitors_14d": 7,
+          "clones_14d": 31,
+          "unique_cloners_14d": 22,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-09-19T15:22:45Z",
+          "updated_at": "2025-11-27T03:46:04Z",
+          "topics": [
+            "ai",
+            "interpretability",
+            "machine-learning"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/interpretability",
+          "name": "interpretability",
+          "timestamp": "2025-12-15T12:03:20.243828+00:00",
+          "stars": 5,
+          "forks": 0,
+          "watchers": 7,
+          "open_issues": 1,
+          "size": 552941,
+          "views_14d": 40,
+          "unique_visitors_14d": 6,
+          "clones_14d": 38,
+          "unique_cloners_14d": 22,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-09-19T15:22:45Z",
+          "updated_at": "2025-12-08T20:21:38Z",
+          "topics": [
+            "ai",
+            "interpretability",
+            "machine-learning"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/interpretability",
+          "name": "interpretability",
+          "timestamp": "2025-12-22T12:03:03.879240+00:00",
+          "stars": 5,
+          "forks": 0,
+          "watchers": 7,
+          "open_issues": 1,
+          "size": 552941,
+          "views_14d": 31,
+          "unique_visitors_14d": 6,
+          "clones_14d": 26,
+          "unique_cloners_14d": 15,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-09-19T15:22:45Z",
+          "updated_at": "2025-12-08T20:21:38Z",
+          "topics": [
+            "ai",
+            "interpretability",
+            "machine-learning"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/interpretability",
+          "name": "interpretability",
+          "timestamp": "2025-12-23T15:53:15.383743+00:00",
+          "stars": 5,
+          "forks": 0,
+          "watchers": 7,
+          "open_issues": 1,
+          "size": 552941,
+          "views_14d": 13,
+          "unique_visitors_14d": 5,
+          "clones_14d": 13,
+          "unique_cloners_14d": 9,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-09-19T15:22:45Z",
+          "updated_at": "2025-12-08T20:21:38Z",
+          "topics": [
+            "ai",
+            "interpretability",
+            "machine-learning"
+          ]
         }
       ]
     },
@@ -3582,6 +4890,110 @@
             "vllm",
             "vlm"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/vector-inference",
+          "name": "vector-inference",
+          "timestamp": "2025-12-08T12:03:06.799186+00:00",
+          "stars": 86,
+          "forks": 12,
+          "watchers": 7,
+          "open_issues": 5,
+          "size": 5970,
+          "views_14d": 226,
+          "unique_visitors_14d": 71,
+          "clones_14d": 285,
+          "unique_cloners_14d": 121,
+          "language": "Python",
+          "created_at": "2024-03-06T01:36:48Z",
+          "updated_at": "2025-12-07T20:51:14Z",
+          "topics": [
+            "inference",
+            "llm",
+            "llm-inference",
+            "reward-modeling",
+            "text-embedding",
+            "vllm",
+            "vlm"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/vector-inference",
+          "name": "vector-inference",
+          "timestamp": "2025-12-15T12:03:26.001995+00:00",
+          "stars": 86,
+          "forks": 12,
+          "watchers": 7,
+          "open_issues": 6,
+          "size": 4868,
+          "views_14d": 408,
+          "unique_visitors_14d": 77,
+          "clones_14d": 313,
+          "unique_cloners_14d": 126,
+          "language": "Python",
+          "created_at": "2024-03-06T01:36:48Z",
+          "updated_at": "2025-12-14T23:21:23Z",
+          "topics": [
+            "inference",
+            "llm",
+            "llm-inference",
+            "reward-modeling",
+            "text-embedding",
+            "vllm",
+            "vlm"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/vector-inference",
+          "name": "vector-inference",
+          "timestamp": "2025-12-22T12:03:08.915887+00:00",
+          "stars": 87,
+          "forks": 12,
+          "watchers": 7,
+          "open_issues": 9,
+          "size": 4915,
+          "views_14d": 462,
+          "unique_visitors_14d": 90,
+          "clones_14d": 215,
+          "unique_cloners_14d": 92,
+          "language": "Python",
+          "created_at": "2024-03-06T01:36:48Z",
+          "updated_at": "2025-12-16T00:45:27Z",
+          "topics": [
+            "inference",
+            "llm",
+            "llm-inference",
+            "reward-modeling",
+            "text-embedding",
+            "vllm",
+            "vlm"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/vector-inference",
+          "name": "vector-inference",
+          "timestamp": "2025-12-23T15:52:49.231622+00:00",
+          "stars": 87,
+          "forks": 12,
+          "watchers": 7,
+          "open_issues": 9,
+          "size": 4915,
+          "views_14d": 395,
+          "unique_visitors_14d": 80,
+          "clones_14d": 208,
+          "unique_cloners_14d": 86,
+          "language": "Python",
+          "created_at": "2024-03-06T01:36:48Z",
+          "updated_at": "2025-12-16T00:45:27Z",
+          "topics": [
+            "inference",
+            "llm",
+            "llm-inference",
+            "reward-modeling",
+            "text-embedding",
+            "vllm",
+            "vlm"
+          ]
         }
       ]
     },
@@ -3797,38 +5209,122 @@
             "diffusion-models",
             "synthetic-data"
           ]
-        }
-      ]
-    },
-    "VectorInstitute/pmc-data-extraction": {
-      "name": "pmc-data-extraction",
-      "snapshots": [
+        },
         {
-          "repo_id": "VectorInstitute/pmc-data-extraction",
-          "name": "pmc-data-extraction",
-          "timestamp": "2025-11-25T19:21:23.971966+00:00",
-          "stars": 13,
-          "forks": 1,
-          "watchers": 1,
-          "open_issues": 6,
-          "size": 13482,
-          "views_14d": null,
-          "unique_visitors_14d": null,
-          "clones_14d": null,
-          "unique_cloners_14d": null,
+          "repo_id": "VectorInstitute/diffusion-models",
+          "name": "diffusion-models",
+          "timestamp": "2025-12-08T12:02:53.474920+00:00",
+          "stars": 5,
+          "forks": 0,
+          "watchers": 10,
+          "open_issues": 1,
+          "size": 272452,
+          "views_14d": 22,
+          "unique_visitors_14d": 7,
+          "clones_14d": 10,
+          "unique_cloners_14d": 7,
           "language": "Jupyter Notebook",
-          "created_at": "2024-09-12T17:32:48Z",
-          "updated_at": "2025-10-13T05:39:15Z",
-          "topics": []
+          "created_at": "2024-06-12T17:52:14Z",
+          "updated_at": "2025-12-01T17:38:22Z",
+          "topics": [
+            "diffusion-models",
+            "synthetic-data"
+          ]
         },
         {
-          "repo_id": "VectorInstitute/pmc-data-extraction",
-          "name": "pmc-data-extraction",
-          "timestamp": "2025-11-25T19:49:35.668621+00:00",
-          "stars": 13,
-          "forks": 1,
-          "watchers": 1,
-          "open_issues": 6,
+          "repo_id": "VectorInstitute/diffusion-models",
+          "name": "diffusion-models",
+          "timestamp": "2025-12-15T12:03:09.422831+00:00",
+          "stars": 5,
+          "forks": 0,
+          "watchers": 10,
+          "open_issues": 1,
+          "size": 272452,
+          "views_14d": 8,
+          "unique_visitors_14d": 4,
+          "clones_14d": 9,
+          "unique_cloners_14d": 7,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-06-12T17:52:14Z",
+          "updated_at": "2025-12-01T17:38:22Z",
+          "topics": [
+            "diffusion-models",
+            "synthetic-data"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/diffusion-models",
+          "name": "diffusion-models",
+          "timestamp": "2025-12-22T12:02:56.030374+00:00",
+          "stars": 5,
+          "forks": 0,
+          "watchers": 10,
+          "open_issues": 1,
+          "size": 272452,
+          "views_14d": 4,
+          "unique_visitors_14d": 4,
+          "clones_14d": 12,
+          "unique_cloners_14d": 8,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-06-12T17:52:14Z",
+          "updated_at": "2025-12-01T17:38:22Z",
+          "topics": [
+            "diffusion-models",
+            "synthetic-data"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/diffusion-models",
+          "name": "diffusion-models",
+          "timestamp": "2025-12-23T15:53:16.421367+00:00",
+          "stars": 5,
+          "forks": 0,
+          "watchers": 10,
+          "open_issues": 1,
+          "size": 272452,
+          "views_14d": 4,
+          "unique_visitors_14d": 4,
+          "clones_14d": 14,
+          "unique_cloners_14d": 8,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-06-12T17:52:14Z",
+          "updated_at": "2025-12-01T17:38:22Z",
+          "topics": [
+            "diffusion-models",
+            "synthetic-data"
+          ]
+        }
+      ]
+    },
+    "VectorInstitute/pmc-data-extraction": {
+      "name": "pmc-data-extraction",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/pmc-data-extraction",
+          "name": "pmc-data-extraction",
+          "timestamp": "2025-11-25T19:21:23.971966+00:00",
+          "stars": 13,
+          "forks": 1,
+          "watchers": 1,
+          "open_issues": 6,
+          "size": 13482,
+          "views_14d": null,
+          "unique_visitors_14d": null,
+          "clones_14d": null,
+          "unique_cloners_14d": null,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-09-12T17:32:48Z",
+          "updated_at": "2025-10-13T05:39:15Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/pmc-data-extraction",
+          "name": "pmc-data-extraction",
+          "timestamp": "2025-11-25T19:49:35.668621+00:00",
+          "stars": 13,
+          "forks": 1,
+          "watchers": 1,
+          "open_issues": 6,
           "size": 13482,
           "views_14d": 31,
           "unique_visitors_14d": 9,
@@ -3982,6 +5478,78 @@
           "created_at": "2024-09-12T17:32:48Z",
           "updated_at": "2025-10-13T05:39:15Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/pmc-data-extraction",
+          "name": "pmc-data-extraction",
+          "timestamp": "2025-12-08T12:02:59.448947+00:00",
+          "stars": 13,
+          "forks": 1,
+          "watchers": 1,
+          "open_issues": 6,
+          "size": 13482,
+          "views_14d": 49,
+          "unique_visitors_14d": 19,
+          "clones_14d": 5,
+          "unique_cloners_14d": 5,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-09-12T17:32:48Z",
+          "updated_at": "2025-10-13T05:39:15Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/pmc-data-extraction",
+          "name": "pmc-data-extraction",
+          "timestamp": "2025-12-15T12:03:17.782106+00:00",
+          "stars": 13,
+          "forks": 1,
+          "watchers": 1,
+          "open_issues": 6,
+          "size": 13482,
+          "views_14d": 172,
+          "unique_visitors_14d": 13,
+          "clones_14d": 6,
+          "unique_cloners_14d": 5,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-09-12T17:32:48Z",
+          "updated_at": "2025-10-13T05:39:15Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/pmc-data-extraction",
+          "name": "pmc-data-extraction",
+          "timestamp": "2025-12-22T12:03:02.000786+00:00",
+          "stars": 14,
+          "forks": 1,
+          "watchers": 1,
+          "open_issues": 6,
+          "size": 13482,
+          "views_14d": 390,
+          "unique_visitors_14d": 19,
+          "clones_14d": 12,
+          "unique_cloners_14d": 11,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-09-12T17:32:48Z",
+          "updated_at": "2025-12-19T18:38:11Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/pmc-data-extraction",
+          "name": "pmc-data-extraction",
+          "timestamp": "2025-12-23T15:53:18.349914+00:00",
+          "stars": 14,
+          "forks": 1,
+          "watchers": 1,
+          "open_issues": 6,
+          "size": 13482,
+          "views_14d": 283,
+          "unique_visitors_14d": 17,
+          "clones_14d": 11,
+          "unique_cloners_14d": 10,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-09-12T17:32:48Z",
+          "updated_at": "2025-12-19T18:38:11Z",
+          "topics": []
         }
       ]
     },
@@ -4182,6 +5750,90 @@
             "ai",
             "deployment"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/ai-deployment",
+          "name": "ai-deployment",
+          "timestamp": "2025-12-08T12:02:58.704168+00:00",
+          "stars": 8,
+          "forks": 29,
+          "watchers": 4,
+          "open_issues": 0,
+          "size": 18502,
+          "views_14d": 24,
+          "unique_visitors_14d": 5,
+          "clones_14d": 24,
+          "unique_cloners_14d": 23,
+          "language": "Python",
+          "created_at": "2024-06-03T19:08:04Z",
+          "updated_at": "2025-11-27T02:32:45Z",
+          "topics": [
+            "ai",
+            "deployment"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/ai-deployment",
+          "name": "ai-deployment",
+          "timestamp": "2025-12-15T12:03:16.892337+00:00",
+          "stars": 8,
+          "forks": 29,
+          "watchers": 4,
+          "open_issues": 0,
+          "size": 18502,
+          "views_14d": 7,
+          "unique_visitors_14d": 4,
+          "clones_14d": 13,
+          "unique_cloners_14d": 10,
+          "language": "Python",
+          "created_at": "2024-06-03T19:08:04Z",
+          "updated_at": "2025-11-27T02:32:45Z",
+          "topics": [
+            "ai",
+            "deployment"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/ai-deployment",
+          "name": "ai-deployment",
+          "timestamp": "2025-12-22T12:03:01.331583+00:00",
+          "stars": 8,
+          "forks": 29,
+          "watchers": 4,
+          "open_issues": 0,
+          "size": 18502,
+          "views_14d": 4,
+          "unique_visitors_14d": 4,
+          "clones_14d": 10,
+          "unique_cloners_14d": 9,
+          "language": "Python",
+          "created_at": "2024-06-03T19:08:04Z",
+          "updated_at": "2025-11-27T02:32:45Z",
+          "topics": [
+            "ai",
+            "deployment"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/ai-deployment",
+          "name": "ai-deployment",
+          "timestamp": "2025-12-23T15:53:26.312750+00:00",
+          "stars": 8,
+          "forks": 29,
+          "watchers": 4,
+          "open_issues": 0,
+          "size": 18502,
+          "views_14d": 2,
+          "unique_visitors_14d": 2,
+          "clones_14d": 10,
+          "unique_cloners_14d": 9,
+          "language": "Python",
+          "created_at": "2024-06-03T19:08:04Z",
+          "updated_at": "2025-11-27T02:32:45Z",
+          "topics": [
+            "ai",
+            "deployment"
+          ]
         }
       ]
     },
@@ -4367,41 +6019,113 @@
           "created_at": "2024-10-09T20:05:04Z",
           "updated_at": "2025-09-01T03:13:59Z",
           "topics": []
-        }
-      ]
-    },
-    "vectorinstitute/retrieval-augmented-generation": {
-      "name": "retrieval-augmented-generation",
-      "snapshots": [
-        {
-          "repo_id": "vectorinstitute/retrieval-augmented-generation",
-          "name": "retrieval-augmented-generation",
-          "timestamp": "2025-11-25T19:21:27.264724+00:00",
-          "stars": 31,
-          "forks": 21,
-          "watchers": 24,
-          "open_issues": 1,
-          "size": 49071,
-          "views_14d": 119,
-          "unique_visitors_14d": 31,
-          "clones_14d": 15,
-          "unique_cloners_14d": 10,
-          "language": "Jupyter Notebook",
-          "created_at": "2023-11-30T19:17:30Z",
-          "updated_at": "2025-11-10T07:08:08Z",
-          "topics": []
         },
         {
-          "repo_id": "vectorinstitute/retrieval-augmented-generation",
-          "name": "retrieval-augmented-generation",
-          "timestamp": "2025-11-25T19:49:38.698670+00:00",
-          "stars": 31,
-          "forks": 21,
-          "watchers": 24,
-          "open_issues": 1,
-          "size": 49071,
-          "views_14d": 119,
-          "unique_visitors_14d": 31,
+          "repo_id": "VectorInstitute/bias-mitigation-unlearning",
+          "name": "bias-mitigation-unlearning",
+          "timestamp": "2025-12-08T12:02:50.768282+00:00",
+          "stars": 3,
+          "forks": 2,
+          "watchers": 1,
+          "open_issues": 6,
+          "size": 383,
+          "views_14d": 27,
+          "unique_visitors_14d": 3,
+          "clones_14d": 6,
+          "unique_cloners_14d": 6,
+          "language": "Python",
+          "created_at": "2024-10-09T20:05:04Z",
+          "updated_at": "2025-09-01T03:13:59Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/bias-mitigation-unlearning",
+          "name": "bias-mitigation-unlearning",
+          "timestamp": "2025-12-15T12:03:06.166786+00:00",
+          "stars": 3,
+          "forks": 2,
+          "watchers": 1,
+          "open_issues": 6,
+          "size": 383,
+          "views_14d": 5,
+          "unique_visitors_14d": 3,
+          "clones_14d": 6,
+          "unique_cloners_14d": 6,
+          "language": "Python",
+          "created_at": "2024-10-09T20:05:04Z",
+          "updated_at": "2025-09-01T03:13:59Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/bias-mitigation-unlearning",
+          "name": "bias-mitigation-unlearning",
+          "timestamp": "2025-12-22T12:02:53.374726+00:00",
+          "stars": 3,
+          "forks": 2,
+          "watchers": 1,
+          "open_issues": 6,
+          "size": 383,
+          "views_14d": 4,
+          "unique_visitors_14d": 3,
+          "clones_14d": 7,
+          "unique_cloners_14d": 6,
+          "language": "Python",
+          "created_at": "2024-10-09T20:05:04Z",
+          "updated_at": "2025-09-01T03:13:59Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/bias-mitigation-unlearning",
+          "name": "bias-mitigation-unlearning",
+          "timestamp": "2025-12-23T15:53:11.359562+00:00",
+          "stars": 3,
+          "forks": 2,
+          "watchers": 1,
+          "open_issues": 6,
+          "size": 383,
+          "views_14d": 4,
+          "unique_visitors_14d": 3,
+          "clones_14d": 7,
+          "unique_cloners_14d": 6,
+          "language": "Python",
+          "created_at": "2024-10-09T20:05:04Z",
+          "updated_at": "2025-09-01T03:13:59Z",
+          "topics": []
+        }
+      ]
+    },
+    "vectorinstitute/retrieval-augmented-generation": {
+      "name": "retrieval-augmented-generation",
+      "snapshots": [
+        {
+          "repo_id": "vectorinstitute/retrieval-augmented-generation",
+          "name": "retrieval-augmented-generation",
+          "timestamp": "2025-11-25T19:21:27.264724+00:00",
+          "stars": 31,
+          "forks": 21,
+          "watchers": 24,
+          "open_issues": 1,
+          "size": 49071,
+          "views_14d": 119,
+          "unique_visitors_14d": 31,
+          "clones_14d": 15,
+          "unique_cloners_14d": 10,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-11-30T19:17:30Z",
+          "updated_at": "2025-11-10T07:08:08Z",
+          "topics": []
+        },
+        {
+          "repo_id": "vectorinstitute/retrieval-augmented-generation",
+          "name": "retrieval-augmented-generation",
+          "timestamp": "2025-11-25T19:49:38.698670+00:00",
+          "stars": 31,
+          "forks": 21,
+          "watchers": 24,
+          "open_issues": 1,
+          "size": 49071,
+          "views_14d": 119,
+          "unique_visitors_14d": 31,
           "clones_14d": 15,
           "unique_cloners_14d": 10,
           "language": "Jupyter Notebook",
@@ -4567,6 +6291,90 @@
             "rag",
             "retrieval-augmented-generation"
           ]
+        },
+        {
+          "repo_id": "vectorinstitute/retrieval-augmented-generation",
+          "name": "retrieval-augmented-generation",
+          "timestamp": "2025-12-08T12:02:46.842259+00:00",
+          "stars": 30,
+          "forks": 21,
+          "watchers": 24,
+          "open_issues": 3,
+          "size": 49315,
+          "views_14d": 171,
+          "unique_visitors_14d": 30,
+          "clones_14d": 109,
+          "unique_cloners_14d": 54,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-11-30T19:17:30Z",
+          "updated_at": "2025-12-01T17:38:11Z",
+          "topics": [
+            "rag",
+            "retrieval-augmented-generation"
+          ]
+        },
+        {
+          "repo_id": "vectorinstitute/retrieval-augmented-generation",
+          "name": "retrieval-augmented-generation",
+          "timestamp": "2025-12-15T12:03:00.958229+00:00",
+          "stars": 30,
+          "forks": 21,
+          "watchers": 24,
+          "open_issues": 2,
+          "size": 49324,
+          "views_14d": 71,
+          "unique_visitors_14d": 28,
+          "clones_14d": 73,
+          "unique_cloners_14d": 42,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-11-30T19:17:30Z",
+          "updated_at": "2025-12-09T20:41:59Z",
+          "topics": [
+            "rag",
+            "retrieval-augmented-generation"
+          ]
+        },
+        {
+          "repo_id": "vectorinstitute/retrieval-augmented-generation",
+          "name": "retrieval-augmented-generation",
+          "timestamp": "2025-12-22T12:02:49.258416+00:00",
+          "stars": 30,
+          "forks": 21,
+          "watchers": 24,
+          "open_issues": 1,
+          "size": 49324,
+          "views_14d": 70,
+          "unique_visitors_14d": 23,
+          "clones_14d": 70,
+          "unique_cloners_14d": 39,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-11-30T19:17:30Z",
+          "updated_at": "2025-12-15T14:42:58Z",
+          "topics": [
+            "rag",
+            "retrieval-augmented-generation"
+          ]
+        },
+        {
+          "repo_id": "vectorinstitute/retrieval-augmented-generation",
+          "name": "retrieval-augmented-generation",
+          "timestamp": "2025-12-23T15:53:09.340353+00:00",
+          "stars": 30,
+          "forks": 21,
+          "watchers": 24,
+          "open_issues": 1,
+          "size": 49324,
+          "views_14d": 61,
+          "unique_visitors_14d": 21,
+          "clones_14d": 54,
+          "unique_cloners_14d": 31,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-11-30T19:17:30Z",
+          "updated_at": "2025-12-15T14:42:58Z",
+          "topics": [
+            "rag",
+            "retrieval-augmented-generation"
+          ]
         }
       ]
     },
@@ -4752,6 +6560,78 @@
           "created_at": "2025-05-22T15:49:19Z",
           "updated_at": "2025-11-25T20:44:42Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/crisp-nam",
+          "name": "crisp-nam",
+          "timestamp": "2025-12-08T12:02:54.816063+00:00",
+          "stars": 2,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 7170,
+          "views_14d": 21,
+          "unique_visitors_14d": 4,
+          "clones_14d": 5,
+          "unique_cloners_14d": 5,
+          "language": "Python",
+          "created_at": "2025-05-22T15:49:19Z",
+          "updated_at": "2025-11-25T20:44:42Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/crisp-nam",
+          "name": "crisp-nam",
+          "timestamp": "2025-12-15T12:03:10.996893+00:00",
+          "stars": 2,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 7170,
+          "views_14d": 0,
+          "unique_visitors_14d": 0,
+          "clones_14d": 2,
+          "unique_cloners_14d": 2,
+          "language": "Python",
+          "created_at": "2025-05-22T15:49:19Z",
+          "updated_at": "2025-11-25T20:44:42Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/crisp-nam",
+          "name": "crisp-nam",
+          "timestamp": "2025-12-22T12:02:57.276836+00:00",
+          "stars": 2,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 7170,
+          "views_14d": 31,
+          "unique_visitors_14d": 4,
+          "clones_14d": 4,
+          "unique_cloners_14d": 4,
+          "language": "Python",
+          "created_at": "2025-05-22T15:49:19Z",
+          "updated_at": "2025-11-25T20:44:42Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/crisp-nam",
+          "name": "crisp-nam",
+          "timestamp": "2025-12-23T15:52:53.321341+00:00",
+          "stars": 2,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 1,
+          "size": 19525,
+          "views_14d": 45,
+          "unique_visitors_14d": 6,
+          "clones_14d": 16,
+          "unique_cloners_14d": 13,
+          "language": "Python",
+          "created_at": "2025-05-22T15:49:19Z",
+          "updated_at": "2025-11-25T20:44:42Z",
+          "topics": []
         }
       ]
     },
@@ -5017,29 +6897,133 @@
             "zero-shot-classification",
             "zero-shot-retrieval"
           ]
-        }
-      ]
-    },
-    "VectorInstitute/finetuning-and-alignment": {
-      "name": "finetuning-and-alignment",
-      "snapshots": [
-        {
-          "repo_id": "VectorInstitute/finetuning-and-alignment",
-          "name": "finetuning-and-alignment",
-          "timestamp": "2025-11-25T19:21:30.198571+00:00",
-          "stars": 11,
-          "forks": 3,
-          "watchers": 30,
-          "open_issues": 0,
-          "size": 27775,
-          "views_14d": 36,
-          "unique_visitors_14d": 6,
-          "clones_14d": 2,
-          "unique_cloners_14d": 2,
-          "language": "Jupyter Notebook",
-          "created_at": "2024-05-14T03:18:04Z",
-          "updated_at": "2025-08-11T18:05:32Z",
-          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/mmlearn",
+          "name": "mmlearn",
+          "timestamp": "2025-12-08T12:02:56.148932+00:00",
+          "stars": 19,
+          "forks": 3,
+          "watchers": 4,
+          "open_issues": 7,
+          "size": 5296,
+          "views_14d": 25,
+          "unique_visitors_14d": 8,
+          "clones_14d": 66,
+          "unique_cloners_14d": 32,
+          "language": "Python",
+          "created_at": "2024-08-07T18:50:11Z",
+          "updated_at": "2025-12-02T13:31:50Z",
+          "topics": [
+            "clip",
+            "contrastive-learning",
+            "i-jepa",
+            "multi-task-learning",
+            "multimodal-learning",
+            "zero-shot-classification",
+            "zero-shot-retrieval"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/mmlearn",
+          "name": "mmlearn",
+          "timestamp": "2025-12-15T12:03:12.891513+00:00",
+          "stars": 19,
+          "forks": 3,
+          "watchers": 4,
+          "open_issues": 6,
+          "size": 5296,
+          "views_14d": 44,
+          "unique_visitors_14d": 9,
+          "clones_14d": 96,
+          "unique_cloners_14d": 50,
+          "language": "Python",
+          "created_at": "2024-08-07T18:50:11Z",
+          "updated_at": "2025-12-08T20:26:06Z",
+          "topics": [
+            "clip",
+            "contrastive-learning",
+            "i-jepa",
+            "multi-task-learning",
+            "multimodal-learning",
+            "zero-shot-classification",
+            "zero-shot-retrieval"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/mmlearn",
+          "name": "mmlearn",
+          "timestamp": "2025-12-22T12:02:58.625883+00:00",
+          "stars": 19,
+          "forks": 3,
+          "watchers": 4,
+          "open_issues": 6,
+          "size": 5302,
+          "views_14d": 45,
+          "unique_visitors_14d": 13,
+          "clones_14d": 143,
+          "unique_cloners_14d": 69,
+          "language": "Python",
+          "created_at": "2024-08-07T18:50:11Z",
+          "updated_at": "2025-12-16T22:24:53Z",
+          "topics": [
+            "clip",
+            "contrastive-learning",
+            "i-jepa",
+            "multi-task-learning",
+            "multimodal-learning",
+            "zero-shot-classification",
+            "zero-shot-retrieval"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/mmlearn",
+          "name": "mmlearn",
+          "timestamp": "2025-12-23T15:52:54.256364+00:00",
+          "stars": 19,
+          "forks": 3,
+          "watchers": 4,
+          "open_issues": 7,
+          "size": 5305,
+          "views_14d": 32,
+          "unique_visitors_14d": 13,
+          "clones_14d": 125,
+          "unique_cloners_14d": 57,
+          "language": "Python",
+          "created_at": "2024-08-07T18:50:11Z",
+          "updated_at": "2025-12-16T22:24:53Z",
+          "topics": [
+            "clip",
+            "contrastive-learning",
+            "i-jepa",
+            "multi-task-learning",
+            "multimodal-learning",
+            "zero-shot-classification",
+            "zero-shot-retrieval"
+          ]
+        }
+      ]
+    },
+    "VectorInstitute/finetuning-and-alignment": {
+      "name": "finetuning-and-alignment",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/finetuning-and-alignment",
+          "name": "finetuning-and-alignment",
+          "timestamp": "2025-11-25T19:21:30.198571+00:00",
+          "stars": 11,
+          "forks": 3,
+          "watchers": 30,
+          "open_issues": 0,
+          "size": 27775,
+          "views_14d": 36,
+          "unique_visitors_14d": 6,
+          "clones_14d": 2,
+          "unique_cloners_14d": 2,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-05-14T03:18:04Z",
+          "updated_at": "2025-08-11T18:05:32Z",
+          "topics": []
         },
         {
           "repo_id": "VectorInstitute/finetuning-and-alignment",
@@ -5217,6 +7201,90 @@
             "alignment",
             "fine-tuning"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/finetuning-and-alignment",
+          "name": "finetuning-and-alignment",
+          "timestamp": "2025-12-08T12:02:52.793408+00:00",
+          "stars": 11,
+          "forks": 3,
+          "watchers": 30,
+          "open_issues": 0,
+          "size": 27777,
+          "views_14d": 24,
+          "unique_visitors_14d": 6,
+          "clones_14d": 20,
+          "unique_cloners_14d": 18,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-05-14T03:18:04Z",
+          "updated_at": "2025-11-27T02:38:26Z",
+          "topics": [
+            "alignment",
+            "fine-tuning"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/finetuning-and-alignment",
+          "name": "finetuning-and-alignment",
+          "timestamp": "2025-12-15T12:03:08.606931+00:00",
+          "stars": 11,
+          "forks": 3,
+          "watchers": 30,
+          "open_issues": 0,
+          "size": 27777,
+          "views_14d": 4,
+          "unique_visitors_14d": 3,
+          "clones_14d": 15,
+          "unique_cloners_14d": 11,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-05-14T03:18:04Z",
+          "updated_at": "2025-11-27T02:38:26Z",
+          "topics": [
+            "alignment",
+            "fine-tuning"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/finetuning-and-alignment",
+          "name": "finetuning-and-alignment",
+          "timestamp": "2025-12-22T12:02:55.362524+00:00",
+          "stars": 11,
+          "forks": 3,
+          "watchers": 30,
+          "open_issues": 0,
+          "size": 27777,
+          "views_14d": 1,
+          "unique_visitors_14d": 1,
+          "clones_14d": 12,
+          "unique_cloners_14d": 10,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-05-14T03:18:04Z",
+          "updated_at": "2025-11-27T02:38:26Z",
+          "topics": [
+            "alignment",
+            "fine-tuning"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/finetuning-and-alignment",
+          "name": "finetuning-and-alignment",
+          "timestamp": "2025-12-23T15:53:20.334294+00:00",
+          "stars": 11,
+          "forks": 3,
+          "watchers": 30,
+          "open_issues": 0,
+          "size": 27777,
+          "views_14d": 1,
+          "unique_visitors_14d": 1,
+          "clones_14d": 11,
+          "unique_cloners_14d": 9,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-05-14T03:18:04Z",
+          "updated_at": "2025-11-27T02:38:26Z",
+          "topics": [
+            "alignment",
+            "fine-tuning"
+          ]
         }
       ]
     },
@@ -5402,6 +7470,78 @@
           "created_at": "2025-10-15T20:14:06Z",
           "updated_at": "2025-12-03T15:52:15Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/masksql",
+          "name": "masksql",
+          "timestamp": "2025-12-08T12:03:05.351751+00:00",
+          "stars": 1,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 5,
+          "size": 5542,
+          "views_14d": 162,
+          "unique_visitors_14d": 9,
+          "clones_14d": 196,
+          "unique_cloners_14d": 74,
+          "language": "Python",
+          "created_at": "2025-10-15T20:14:06Z",
+          "updated_at": "2025-12-03T15:52:15Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/masksql",
+          "name": "masksql",
+          "timestamp": "2025-12-15T12:03:24.354580+00:00",
+          "stars": 1,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 7,
+          "size": 6198,
+          "views_14d": 205,
+          "unique_visitors_14d": 7,
+          "clones_14d": 234,
+          "unique_cloners_14d": 88,
+          "language": "Python",
+          "created_at": "2025-10-15T20:14:06Z",
+          "updated_at": "2025-12-11T17:32:52Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/masksql",
+          "name": "masksql",
+          "timestamp": "2025-12-22T12:03:07.542904+00:00",
+          "stars": 1,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 3,
+          "size": 6331,
+          "views_14d": 183,
+          "unique_visitors_14d": 5,
+          "clones_14d": 231,
+          "unique_cloners_14d": 71,
+          "language": "Python",
+          "created_at": "2025-10-15T20:14:06Z",
+          "updated_at": "2025-12-18T03:17:33Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/masksql",
+          "name": "masksql",
+          "timestamp": "2025-12-23T15:52:57.230262+00:00",
+          "stars": 1,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 3,
+          "size": 6331,
+          "views_14d": 183,
+          "unique_visitors_14d": 5,
+          "clones_14d": 231,
+          "unique_cloners_14d": 71,
+          "language": "Python",
+          "created_at": "2025-10-15T20:14:06Z",
+          "updated_at": "2025-12-18T03:17:33Z",
+          "topics": []
         }
       ]
     },
@@ -5587,24 +7727,96 @@
           "created_at": "2025-01-08T20:10:48Z",
           "updated_at": "2025-08-29T07:22:56Z",
           "topics": []
-        }
-      ]
-    },
-    "VectorInstitute/FL4Health": {
-      "name": "FL4Health",
-      "snapshots": [
+        },
         {
-          "repo_id": "VectorInstitute/FL4Health",
-          "name": "FL4Health",
-          "timestamp": "2025-11-25T19:21:33.376973+00:00",
-          "stars": 47,
-          "forks": 15,
-          "watchers": 3,
-          "open_issues": 2,
-          "size": 233988,
-          "views_14d": 191,
-          "unique_visitors_14d": 36,
-          "clones_14d": 130,
+          "repo_id": "VectorInstitute/fair-sense-ai",
+          "name": "fair-sense-ai",
+          "timestamp": "2025-12-08T12:03:07.519349+00:00",
+          "stars": 6,
+          "forks": 3,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 13906,
+          "views_14d": 88,
+          "unique_visitors_14d": 25,
+          "clones_14d": 3,
+          "unique_cloners_14d": 3,
+          "language": "Python",
+          "created_at": "2025-01-08T20:10:48Z",
+          "updated_at": "2025-12-04T03:29:22Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/fair-sense-ai",
+          "name": "fair-sense-ai",
+          "timestamp": "2025-12-15T12:03:26.824930+00:00",
+          "stars": 6,
+          "forks": 3,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 13906,
+          "views_14d": 61,
+          "unique_visitors_14d": 26,
+          "clones_14d": 8,
+          "unique_cloners_14d": 8,
+          "language": "Python",
+          "created_at": "2025-01-08T20:10:48Z",
+          "updated_at": "2025-12-04T03:29:22Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/fair-sense-ai",
+          "name": "fair-sense-ai",
+          "timestamp": "2025-12-22T12:03:09.535058+00:00",
+          "stars": 6,
+          "forks": 3,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 13906,
+          "views_14d": 54,
+          "unique_visitors_14d": 13,
+          "clones_14d": 28,
+          "unique_cloners_14d": 23,
+          "language": "Python",
+          "created_at": "2025-01-08T20:10:48Z",
+          "updated_at": "2025-12-04T03:29:22Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/fair-sense-ai",
+          "name": "fair-sense-ai",
+          "timestamp": "2025-12-23T15:53:21.457600+00:00",
+          "stars": 6,
+          "forks": 3,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 13906,
+          "views_14d": 51,
+          "unique_visitors_14d": 10,
+          "clones_14d": 26,
+          "unique_cloners_14d": 21,
+          "language": "Python",
+          "created_at": "2025-01-08T20:10:48Z",
+          "updated_at": "2025-12-04T03:29:22Z",
+          "topics": []
+        }
+      ]
+    },
+    "VectorInstitute/FL4Health": {
+      "name": "FL4Health",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/FL4Health",
+          "name": "FL4Health",
+          "timestamp": "2025-11-25T19:21:33.376973+00:00",
+          "stars": 47,
+          "forks": 15,
+          "watchers": 3,
+          "open_issues": 2,
+          "size": 233988,
+          "views_14d": 191,
+          "unique_visitors_14d": 36,
+          "clones_14d": 130,
           "unique_cloners_14d": 49,
           "language": "Python",
           "created_at": "2022-09-16T12:54:29Z",
@@ -5842,6 +8054,106 @@
             "healthcare",
             "machine-learning"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/FL4Health",
+          "name": "FL4Health",
+          "timestamp": "2025-12-08T12:02:55.479069+00:00",
+          "stars": 51,
+          "forks": 16,
+          "watchers": 3,
+          "open_issues": 0,
+          "size": 234703,
+          "views_14d": 590,
+          "unique_visitors_14d": 96,
+          "clones_14d": 830,
+          "unique_cloners_14d": 255,
+          "language": "Python",
+          "created_at": "2022-09-16T12:54:29Z",
+          "updated_at": "2025-12-08T11:36:21Z",
+          "topics": [
+            "deep-learning",
+            "distributed-learning",
+            "federated-learning",
+            "federated-learning-framework",
+            "healthcare",
+            "machine-learning"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/FL4Health",
+          "name": "FL4Health",
+          "timestamp": "2025-12-15T12:03:11.956838+00:00",
+          "stars": 51,
+          "forks": 16,
+          "watchers": 3,
+          "open_issues": 0,
+          "size": 234706,
+          "views_14d": 637,
+          "unique_visitors_14d": 80,
+          "clones_14d": 631,
+          "unique_cloners_14d": 169,
+          "language": "Python",
+          "created_at": "2022-09-16T12:54:29Z",
+          "updated_at": "2025-12-12T20:10:46Z",
+          "topics": [
+            "deep-learning",
+            "distributed-learning",
+            "federated-learning",
+            "federated-learning-framework",
+            "healthcare",
+            "machine-learning"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/FL4Health",
+          "name": "FL4Health",
+          "timestamp": "2025-12-22T12:02:57.888092+00:00",
+          "stars": 51,
+          "forks": 16,
+          "watchers": 3,
+          "open_issues": 3,
+          "size": 235209,
+          "views_14d": 330,
+          "unique_visitors_14d": 38,
+          "clones_14d": 231,
+          "unique_cloners_14d": 77,
+          "language": "Python",
+          "created_at": "2022-09-16T12:54:29Z",
+          "updated_at": "2025-12-16T20:57:39Z",
+          "topics": [
+            "deep-learning",
+            "distributed-learning",
+            "federated-learning",
+            "federated-learning-framework",
+            "healthcare",
+            "machine-learning"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/FL4Health",
+          "name": "FL4Health",
+          "timestamp": "2025-12-23T15:53:00.669147+00:00",
+          "stars": 51,
+          "forks": 16,
+          "watchers": 3,
+          "open_issues": 4,
+          "size": 235211,
+          "views_14d": 343,
+          "unique_visitors_14d": 39,
+          "clones_14d": 221,
+          "unique_cloners_14d": 73,
+          "language": "Python",
+          "created_at": "2022-09-16T12:54:29Z",
+          "updated_at": "2025-12-16T20:57:39Z",
+          "topics": [
+            "deep-learning",
+            "distributed-learning",
+            "federated-learning",
+            "federated-learning-framework",
+            "healthcare",
+            "machine-learning"
+          ]
         }
       ]
     },
@@ -5973,6 +8285,78 @@
           "created_at": "2025-06-09T17:34:32Z",
           "updated_at": "2025-11-25T20:14:47Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/linguamark",
+          "name": "linguamark",
+          "timestamp": "2025-12-08T12:02:51.427255+00:00",
+          "stars": 0,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 17052,
+          "views_14d": 32,
+          "unique_visitors_14d": 4,
+          "clones_14d": 4,
+          "unique_cloners_14d": 4,
+          "language": "Python",
+          "created_at": "2025-06-09T17:34:32Z",
+          "updated_at": "2025-11-25T20:14:47Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/linguamark",
+          "name": "linguamark",
+          "timestamp": "2025-12-15T12:03:06.995122+00:00",
+          "stars": 0,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 17052,
+          "views_14d": 7,
+          "unique_visitors_14d": 2,
+          "clones_14d": 2,
+          "unique_cloners_14d": 2,
+          "language": "Python",
+          "created_at": "2025-06-09T17:34:32Z",
+          "updated_at": "2025-11-25T20:14:47Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/linguamark",
+          "name": "linguamark",
+          "timestamp": "2025-12-22T12:02:54.013939+00:00",
+          "stars": 0,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 17052,
+          "views_14d": 1,
+          "unique_visitors_14d": 1,
+          "clones_14d": 3,
+          "unique_cloners_14d": 3,
+          "language": "Python",
+          "created_at": "2025-06-09T17:34:32Z",
+          "updated_at": "2025-11-25T20:14:47Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/linguamark",
+          "name": "linguamark",
+          "timestamp": "2025-12-23T15:53:25.326595+00:00",
+          "stars": 0,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 17052,
+          "views_14d": 1,
+          "unique_visitors_14d": 1,
+          "clones_14d": 3,
+          "unique_cloners_14d": 3,
+          "language": "Python",
+          "created_at": "2025-06-09T17:34:32Z",
+          "updated_at": "2025-11-25T20:14:47Z",
+          "topics": []
         }
       ]
     },
@@ -6132,42 +8516,130 @@
             "multimodal-large-language-models",
             "vlm"
           ]
-        }
-      ]
-    },
-    "VectorInstitute/vbll": {
-      "name": "vbll",
-      "snapshots": [
+        },
         {
-          "repo_id": "VectorInstitute/vbll",
-          "name": "vbll",
-          "timestamp": "2025-11-27T13:38:31.053754+00:00",
-          "stars": 77,
-          "forks": 7,
-          "watchers": 2,
-          "open_issues": 4,
-          "size": 551,
-          "views_14d": null,
-          "unique_visitors_14d": null,
-          "clones_14d": null,
-          "unique_cloners_14d": null,
+          "repo_id": "VectorInstitute/humanibench",
+          "name": "humanibench",
+          "timestamp": "2025-12-08T12:02:48.804706+00:00",
+          "stars": 6,
+          "forks": 1,
+          "watchers": 1,
+          "open_issues": 0,
+          "size": 21607,
+          "views_14d": 180,
+          "unique_visitors_14d": 21,
+          "clones_14d": 85,
+          "unique_cloners_14d": 57,
           "language": "Python",
-          "created_at": "2023-10-11T15:26:23Z",
-          "updated_at": "2025-11-11T10:51:53Z",
-          "topics": []
+          "created_at": "2025-01-28T14:55:04Z",
+          "updated_at": "2025-11-27T21:43:32Z",
+          "topics": [
+            "evaluation-framework",
+            "multimodal-large-language-models",
+            "vlm"
+          ]
         },
         {
-          "repo_id": "VectorInstitute/vbll",
-          "name": "vbll",
-          "timestamp": "2025-11-27T14:00:51.987742+00:00",
-          "stars": 77,
-          "forks": 7,
-          "watchers": 2,
-          "open_issues": 4,
-          "size": 551,
-          "views_14d": null,
-          "unique_visitors_14d": null,
-          "clones_14d": null,
+          "repo_id": "VectorInstitute/humanibench",
+          "name": "humanibench",
+          "timestamp": "2025-12-15T12:03:03.748234+00:00",
+          "stars": 6,
+          "forks": 1,
+          "watchers": 1,
+          "open_issues": 0,
+          "size": 21607,
+          "views_14d": 58,
+          "unique_visitors_14d": 11,
+          "clones_14d": 39,
+          "unique_cloners_14d": 25,
+          "language": "Python",
+          "created_at": "2025-01-28T14:55:04Z",
+          "updated_at": "2025-11-27T21:43:32Z",
+          "topics": [
+            "evaluation-framework",
+            "multimodal-large-language-models",
+            "vlm"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/humanibench",
+          "name": "humanibench",
+          "timestamp": "2025-12-22T12:02:51.293188+00:00",
+          "stars": 6,
+          "forks": 1,
+          "watchers": 1,
+          "open_issues": 0,
+          "size": 21607,
+          "views_14d": 24,
+          "unique_visitors_14d": 12,
+          "clones_14d": 9,
+          "unique_cloners_14d": 9,
+          "language": "Python",
+          "created_at": "2025-01-28T14:55:04Z",
+          "updated_at": "2025-11-27T21:43:32Z",
+          "topics": [
+            "evaluation-framework",
+            "multimodal-large-language-models",
+            "vlm"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/humanibench",
+          "name": "humanibench",
+          "timestamp": "2025-12-23T15:53:13.401822+00:00",
+          "stars": 6,
+          "forks": 1,
+          "watchers": 1,
+          "open_issues": 0,
+          "size": 21607,
+          "views_14d": 45,
+          "unique_visitors_14d": 11,
+          "clones_14d": 11,
+          "unique_cloners_14d": 11,
+          "language": "Python",
+          "created_at": "2025-01-28T14:55:04Z",
+          "updated_at": "2025-11-27T21:43:32Z",
+          "topics": [
+            "evaluation-framework",
+            "multimodal-large-language-models",
+            "vlm"
+          ]
+        }
+      ]
+    },
+    "VectorInstitute/vbll": {
+      "name": "vbll",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/vbll",
+          "name": "vbll",
+          "timestamp": "2025-11-27T13:38:31.053754+00:00",
+          "stars": 77,
+          "forks": 7,
+          "watchers": 2,
+          "open_issues": 4,
+          "size": 551,
+          "views_14d": null,
+          "unique_visitors_14d": null,
+          "clones_14d": null,
+          "unique_cloners_14d": null,
+          "language": "Python",
+          "created_at": "2023-10-11T15:26:23Z",
+          "updated_at": "2025-11-11T10:51:53Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/vbll",
+          "name": "vbll",
+          "timestamp": "2025-11-27T14:00:51.987742+00:00",
+          "stars": 77,
+          "forks": 7,
+          "watchers": 2,
+          "open_issues": 4,
+          "size": 551,
+          "views_14d": null,
+          "unique_visitors_14d": null,
+          "clones_14d": null,
           "unique_cloners_14d": null,
           "language": "Python",
           "created_at": "2023-10-11T15:26:23Z",
@@ -6227,6 +8699,78 @@
           "created_at": "2023-10-11T15:26:23Z",
           "updated_at": "2025-12-02T04:43:16Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/vbll",
+          "name": "vbll",
+          "timestamp": "2025-12-08T12:03:06.067732+00:00",
+          "stars": 78,
+          "forks": 7,
+          "watchers": 2,
+          "open_issues": 4,
+          "size": 551,
+          "views_14d": 310,
+          "unique_visitors_14d": 38,
+          "clones_14d": 5,
+          "unique_cloners_14d": 5,
+          "language": "Python",
+          "created_at": "2023-10-11T15:26:23Z",
+          "updated_at": "2025-12-02T04:43:16Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/vbll",
+          "name": "vbll",
+          "timestamp": "2025-12-15T12:03:25.229111+00:00",
+          "stars": 78,
+          "forks": 8,
+          "watchers": 2,
+          "open_issues": 4,
+          "size": 551,
+          "views_14d": 271,
+          "unique_visitors_14d": 36,
+          "clones_14d": 11,
+          "unique_cloners_14d": 9,
+          "language": "Python",
+          "created_at": "2023-10-11T15:26:23Z",
+          "updated_at": "2025-12-02T04:43:16Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/vbll",
+          "name": "vbll",
+          "timestamp": "2025-12-22T12:03:08.241459+00:00",
+          "stars": 79,
+          "forks": 8,
+          "watchers": 2,
+          "open_issues": 4,
+          "size": 551,
+          "views_14d": 198,
+          "unique_visitors_14d": 37,
+          "clones_14d": 20,
+          "unique_cloners_14d": 17,
+          "language": "Python",
+          "created_at": "2023-10-11T15:26:23Z",
+          "updated_at": "2025-12-22T01:59:04Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/vbll",
+          "name": "vbll",
+          "timestamp": "2025-12-23T15:53:07.389330+00:00",
+          "stars": 79,
+          "forks": 8,
+          "watchers": 2,
+          "open_issues": 4,
+          "size": 551,
+          "views_14d": 179,
+          "unique_visitors_14d": 36,
+          "clones_14d": 21,
+          "unique_cloners_14d": 18,
+          "language": "Python",
+          "created_at": "2023-10-11T15:26:23Z",
+          "updated_at": "2025-12-22T01:59:04Z",
+          "topics": []
         }
       ]
     },
@@ -6316,6 +8860,90 @@
             "hvac-control",
             "reinforcement-learning"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/HV-Ai-C",
+          "name": "HV-Ai-C",
+          "timestamp": "2025-12-08T12:03:00.859081+00:00",
+          "stars": 74,
+          "forks": 22,
+          "watchers": 6,
+          "open_issues": 1,
+          "size": 223,
+          "views_14d": 71,
+          "unique_visitors_14d": 40,
+          "clones_14d": 14,
+          "unique_cloners_14d": 7,
+          "language": "Python",
+          "created_at": "2022-03-03T16:55:04Z",
+          "updated_at": "2025-12-03T19:07:08Z",
+          "topics": [
+            "hvac-control",
+            "reinforcement-learning"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/HV-Ai-C",
+          "name": "HV-Ai-C",
+          "timestamp": "2025-12-15T12:03:19.353082+00:00",
+          "stars": 74,
+          "forks": 22,
+          "watchers": 6,
+          "open_issues": 1,
+          "size": 223,
+          "views_14d": 75,
+          "unique_visitors_14d": 27,
+          "clones_14d": 12,
+          "unique_cloners_14d": 11,
+          "language": "Python",
+          "created_at": "2022-03-03T16:55:04Z",
+          "updated_at": "2025-12-03T19:07:08Z",
+          "topics": [
+            "hvac-control",
+            "reinforcement-learning"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/HV-Ai-C",
+          "name": "HV-Ai-C",
+          "timestamp": "2025-12-22T12:03:03.320159+00:00",
+          "stars": 74,
+          "forks": 22,
+          "watchers": 6,
+          "open_issues": 1,
+          "size": 223,
+          "views_14d": 70,
+          "unique_visitors_14d": 24,
+          "clones_14d": 18,
+          "unique_cloners_14d": 16,
+          "language": "Python",
+          "created_at": "2022-03-03T16:55:04Z",
+          "updated_at": "2025-12-03T19:07:08Z",
+          "topics": [
+            "hvac-control",
+            "reinforcement-learning"
+          ]
+        },
+        {
+          "repo_id": "VectorInstitute/HV-Ai-C",
+          "name": "HV-Ai-C",
+          "timestamp": "2025-12-23T15:53:22.417700+00:00",
+          "stars": 74,
+          "forks": 22,
+          "watchers": 6,
+          "open_issues": 1,
+          "size": 223,
+          "views_14d": 41,
+          "unique_visitors_14d": 23,
+          "clones_14d": 16,
+          "unique_cloners_14d": 14,
+          "language": "Python",
+          "created_at": "2022-03-03T16:55:04Z",
+          "updated_at": "2025-12-03T19:07:08Z",
+          "topics": [
+            "hvac-control",
+            "reinforcement-learning"
+          ]
         }
       ]
     },
@@ -6375,9 +9003,229 @@
           "created_at": "2025-03-18T18:06:25Z",
           "updated_at": "2025-11-26T21:32:12Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/mcp-goodnews",
+          "name": "mcp-goodnews",
+          "timestamp": "2025-12-08T12:02:47.491186+00:00",
+          "stars": 44,
+          "forks": 9,
+          "watchers": 0,
+          "open_issues": 1,
+          "size": 101,
+          "views_14d": 67,
+          "unique_visitors_14d": 41,
+          "clones_14d": 59,
+          "unique_cloners_14d": 46,
+          "language": "Python",
+          "created_at": "2025-03-18T18:06:25Z",
+          "updated_at": "2025-11-26T21:32:12Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/mcp-goodnews",
+          "name": "mcp-goodnews",
+          "timestamp": "2025-12-15T12:03:01.971938+00:00",
+          "stars": 44,
+          "forks": 9,
+          "watchers": 0,
+          "open_issues": 1,
+          "size": 101,
+          "views_14d": 56,
+          "unique_visitors_14d": 20,
+          "clones_14d": 44,
+          "unique_cloners_14d": 35,
+          "language": "Python",
+          "created_at": "2025-03-18T18:06:25Z",
+          "updated_at": "2025-11-26T21:32:12Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/mcp-goodnews",
+          "name": "mcp-goodnews",
+          "timestamp": "2025-12-22T12:02:49.970121+00:00",
+          "stars": 44,
+          "forks": 9,
+          "watchers": 0,
+          "open_issues": 1,
+          "size": 101,
+          "views_14d": 53,
+          "unique_visitors_14d": 16,
+          "clones_14d": 48,
+          "unique_cloners_14d": 37,
+          "language": "Python",
+          "created_at": "2025-03-18T18:06:25Z",
+          "updated_at": "2025-11-26T21:32:12Z",
+          "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/mcp-goodnews",
+          "name": "mcp-goodnews",
+          "timestamp": "2025-12-23T15:53:24.335167+00:00",
+          "stars": 44,
+          "forks": 9,
+          "watchers": 0,
+          "open_issues": 1,
+          "size": 101,
+          "views_14d": 45,
+          "unique_visitors_14d": 14,
+          "clones_14d": 44,
+          "unique_cloners_14d": 33,
+          "language": "Python",
+          "created_at": "2025-03-18T18:06:25Z",
+          "updated_at": "2025-11-26T21:32:12Z",
+          "topics": []
+        }
+      ]
+    },
+    "VectorInstitute/aieng-template-webpage": {
+      "name": "aieng-template-webpage",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/aieng-template-webpage",
+          "name": "aieng-template-webpage",
+          "timestamp": "2025-12-23T15:52:50.314764+00:00",
+          "stars": 1,
+          "forks": 0,
+          "watchers": 1,
+          "open_issues": 0,
+          "size": 528,
+          "views_14d": 19,
+          "unique_visitors_14d": 2,
+          "clones_14d": 155,
+          "unique_cloners_14d": 54,
+          "language": "TypeScript",
+          "created_at": "2025-01-17T16:11:31Z",
+          "updated_at": "2025-12-22T07:02:08Z",
+          "topics": []
+        }
+      ]
+    },
+    "VectorInstitute/aieng-template-uv": {
+      "name": "aieng-template-uv",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/aieng-template-uv",
+          "name": "aieng-template-uv",
+          "timestamp": "2025-12-23T15:52:52.307266+00:00",
+          "stars": 7,
+          "forks": 1,
+          "watchers": 3,
+          "open_issues": 0,
+          "size": 2107,
+          "views_14d": 169,
+          "unique_visitors_14d": 11,
+          "clones_14d": 414,
+          "unique_cloners_14d": 131,
+          "language": "Python",
+          "created_at": "2025-01-20T16:19:12Z",
+          "updated_at": "2025-12-23T00:19:19Z",
+          "topics": [
+            "python3",
+            "template"
+          ]
+        }
+      ]
+    },
+    "VectorInstitute/aieng-template-implementation": {
+      "name": "aieng-template-implementation",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/aieng-template-implementation",
+          "name": "aieng-template-implementation",
+          "timestamp": "2025-12-23T15:52:56.244743+00:00",
+          "stars": 1,
+          "forks": 0,
+          "watchers": 7,
+          "open_issues": 0,
+          "size": 5554,
+          "views_14d": 137,
+          "unique_visitors_14d": 5,
+          "clones_14d": 242,
+          "unique_cloners_14d": 89,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-04-24T22:30:50Z",
+          "updated_at": "2025-12-23T03:41:28Z",
+          "topics": [
+            "ai",
+            "implementation",
+            "template"
+          ]
+        }
+      ]
+    },
+    "VectorInstitute/aieng-template-mvp": {
+      "name": "aieng-template-mvp",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/aieng-template-mvp",
+          "name": "aieng-template-mvp",
+          "timestamp": "2025-12-23T15:53:02.646476+00:00",
+          "stars": 2,
+          "forks": 1,
+          "watchers": 1,
+          "open_issues": 1,
+          "size": 2604,
+          "views_14d": 99,
+          "unique_visitors_14d": 4,
+          "clones_14d": 631,
+          "unique_cloners_14d": 126,
+          "language": "Python",
+          "created_at": "2025-04-09T15:30:01Z",
+          "updated_at": "2025-12-22T06:49:52Z",
+          "topics": [
+            "mvp",
+            "template"
+          ]
+        }
+      ]
+    },
+    "VectorInstitute/aieng-template-poetry": {
+      "name": "aieng-template-poetry",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/aieng-template-poetry",
+          "name": "aieng-template-poetry",
+          "timestamp": "2025-12-23T15:53:06.417960+00:00",
+          "stars": 4,
+          "forks": 0,
+          "watchers": 7,
+          "open_issues": 6,
+          "size": 831,
+          "views_14d": 17,
+          "unique_visitors_14d": 5,
+          "clones_14d": 12,
+          "unique_cloners_14d": 8,
+          "language": "Python",
+          "created_at": "2022-03-14T14:55:29Z",
+          "updated_at": "2025-05-15T22:16:23Z",
+          "topics": []
+        }
+      ]
+    },
+    "VectorInstitute/aieng-template-blog": {
+      "name": "aieng-template-blog",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/aieng-template-blog",
+          "name": "aieng-template-blog",
+          "timestamp": "2025-12-23T15:53:08.440350+00:00",
+          "stars": 3,
+          "forks": 0,
+          "watchers": 1,
+          "open_issues": 0,
+          "size": 1052,
+          "views_14d": 133,
+          "unique_visitors_14d": 6,
+          "clones_14d": 398,
+          "unique_cloners_14d": 127,
+          "language": "JavaScript",
+          "created_at": "2025-01-23T16:19:25Z",
+          "updated_at": "2025-12-23T00:19:14Z",
+          "topics": []
         }
       ]
     }
   },
-  "last_updated": "2025-12-03T19:20:18.504534+00:00"
+  "last_updated": "2025-12-23T15:53:26.312750+00:00"
 }
diff --git a/catalog/public/data/github_metrics.json b/catalog/public/data/github_metrics.json
index d618a6f..d32378a 100644
--- a/catalog/public/data/github_metrics.json
+++ b/catalog/public/data/github_metrics.json
@@ -1,166 +1,338 @@
 {
   "repos": {
-    "vectorinstitute/retrieval-augmented-generation": {
-      "repo_id": "vectorinstitute/retrieval-augmented-generation",
-      "name": "retrieval-augmented-generation",
-      "timestamp": "2025-12-22T12:02:49.258416+00:00",
-      "stars": 30,
-      "forks": 21,
-      "watchers": 24,
+    "VectorInstitute/vector-inference": {
+      "repo_id": "VectorInstitute/vector-inference",
+      "name": "vector-inference",
+      "timestamp": "2025-12-23T15:52:49.231622+00:00",
+      "stars": 87,
+      "forks": 12,
+      "watchers": 7,
+      "open_issues": 9,
+      "size": 4915,
+      "views_14d": 395,
+      "unique_visitors_14d": 80,
+      "clones_14d": 208,
+      "unique_cloners_14d": 86,
+      "language": "Python",
+      "created_at": "2024-03-06T01:36:48Z",
+      "updated_at": "2025-12-16T00:45:27Z",
+      "topics": [
+        "inference",
+        "llm",
+        "llm-inference",
+        "reward-modeling",
+        "text-embedding",
+        "vllm",
+        "vlm"
+      ]
+    },
+    "VectorInstitute/aieng-template-webpage": {
+      "repo_id": "VectorInstitute/aieng-template-webpage",
+      "name": "aieng-template-webpage",
+      "timestamp": "2025-12-23T15:52:50.314764+00:00",
+      "stars": 1,
+      "forks": 0,
+      "watchers": 1,
+      "open_issues": 0,
+      "size": 528,
+      "views_14d": 19,
+      "unique_visitors_14d": 2,
+      "clones_14d": 155,
+      "unique_cloners_14d": 54,
+      "language": "TypeScript",
+      "created_at": "2025-01-17T16:11:31Z",
+      "updated_at": "2025-12-22T07:02:08Z",
+      "topics": []
+    },
+    "VectorInstitute/recommender-systems": {
+      "repo_id": "VectorInstitute/recommender-systems",
+      "name": "recommender-systems",
+      "timestamp": "2025-12-23T15:52:51.296878+00:00",
+      "stars": 6,
+      "forks": 0,
+      "watchers": 30,
       "open_issues": 1,
-      "size": 49324,
-      "views_14d": 70,
-      "unique_visitors_14d": 23,
-      "clones_14d": 70,
-      "unique_cloners_14d": 39,
+      "size": 27200,
+      "views_14d": 0,
+      "unique_visitors_14d": 0,
+      "clones_14d": 6,
+      "unique_cloners_14d": 6,
       "language": "Jupyter Notebook",
-      "created_at": "2023-11-30T19:17:30Z",
-      "updated_at": "2025-12-15T14:42:58Z",
+      "created_at": "2022-06-09T21:10:48Z",
+      "updated_at": "2025-05-13T20:17:43Z",
       "topics": [
-        "rag",
-        "retrieval-augmented-generation"
+        "recommender-system"
       ]
     },
-    "VectorInstitute/mcp-goodnews": {
-      "repo_id": "VectorInstitute/mcp-goodnews",
-      "name": "mcp-goodnews",
-      "timestamp": "2025-12-22T12:02:49.970121+00:00",
-      "stars": 44,
-      "forks": 9,
+    "VectorInstitute/aieng-template-uv": {
+      "repo_id": "VectorInstitute/aieng-template-uv",
+      "name": "aieng-template-uv",
+      "timestamp": "2025-12-23T15:52:52.307266+00:00",
+      "stars": 7,
+      "forks": 1,
+      "watchers": 3,
+      "open_issues": 0,
+      "size": 2107,
+      "views_14d": 169,
+      "unique_visitors_14d": 11,
+      "clones_14d": 414,
+      "unique_cloners_14d": 131,
+      "language": "Python",
+      "created_at": "2025-01-20T16:19:12Z",
+      "updated_at": "2025-12-23T00:19:19Z",
+      "topics": [
+        "python3",
+        "template"
+      ]
+    },
+    "VectorInstitute/crisp-nam": {
+      "repo_id": "VectorInstitute/crisp-nam",
+      "name": "crisp-nam",
+      "timestamp": "2025-12-23T15:52:53.321341+00:00",
+      "stars": 2,
+      "forks": 0,
       "watchers": 0,
       "open_issues": 1,
-      "size": 101,
-      "views_14d": 53,
-      "unique_visitors_14d": 16,
-      "clones_14d": 48,
-      "unique_cloners_14d": 37,
+      "size": 19525,
+      "views_14d": 45,
+      "unique_visitors_14d": 6,
+      "clones_14d": 16,
+      "unique_cloners_14d": 13,
       "language": "Python",
-      "created_at": "2025-03-18T18:06:25Z",
-      "updated_at": "2025-11-26T21:32:12Z",
+      "created_at": "2025-05-22T15:49:19Z",
+      "updated_at": "2025-11-25T20:44:42Z",
       "topics": []
     },
-    "VectorInstitute/bias-in-the-picture-benchmark": {
-      "repo_id": "VectorInstitute/bias-in-the-picture-benchmark",
-      "name": "bias-in-the-picture-benchmark",
-      "timestamp": "2025-12-22T12:02:50.647704+00:00",
+    "VectorInstitute/mmlearn": {
+      "repo_id": "VectorInstitute/mmlearn",
+      "name": "mmlearn",
+      "timestamp": "2025-12-23T15:52:54.256364+00:00",
+      "stars": 19,
+      "forks": 3,
+      "watchers": 4,
+      "open_issues": 7,
+      "size": 5305,
+      "views_14d": 32,
+      "unique_visitors_14d": 13,
+      "clones_14d": 125,
+      "unique_cloners_14d": 57,
+      "language": "Python",
+      "created_at": "2024-08-07T18:50:11Z",
+      "updated_at": "2025-12-16T22:24:53Z",
+      "topics": [
+        "clip",
+        "contrastive-learning",
+        "i-jepa",
+        "multi-task-learning",
+        "multimodal-learning",
+        "zero-shot-classification",
+        "zero-shot-retrieval"
+      ]
+    },
+    "VectorInstitute/self-supervised-learning": {
+      "repo_id": "VectorInstitute/self-supervised-learning",
+      "name": "self-supervised-learning",
+      "timestamp": "2025-12-23T15:52:55.204482+00:00",
       "stars": 3,
       "forks": 0,
-      "watchers": 0,
+      "watchers": 18,
       "open_issues": 0,
-      "size": 9705,
-      "views_14d": 4,
-      "unique_visitors_14d": 4,
-      "clones_14d": 4,
-      "unique_cloners_14d": 4,
-      "language": "Python",
-      "created_at": "2025-11-21T16:57:41Z",
-      "updated_at": "2025-11-26T21:34:25Z",
-      "topics": []
+      "size": 84026,
+      "views_14d": 3,
+      "unique_visitors_14d": 3,
+      "clones_14d": 3,
+      "unique_cloners_14d": 3,
+      "language": "Jupyter Notebook",
+      "created_at": "2023-08-17T15:25:42Z",
+      "updated_at": "2025-11-26T21:28:48Z",
+      "topics": [
+        "contrastive-learning",
+        "masked-modelling",
+        "self-distillation",
+        "self-supervised-learning"
+      ]
     },
-    "VectorInstitute/humanibench": {
-      "repo_id": "VectorInstitute/humanibench",
-      "name": "humanibench",
-      "timestamp": "2025-12-22T12:02:51.293188+00:00",
-      "stars": 6,
-      "forks": 1,
-      "watchers": 1,
+    "VectorInstitute/aieng-template-implementation": {
+      "repo_id": "VectorInstitute/aieng-template-implementation",
+      "name": "aieng-template-implementation",
+      "timestamp": "2025-12-23T15:52:56.244743+00:00",
+      "stars": 1,
+      "forks": 0,
+      "watchers": 7,
       "open_issues": 0,
-      "size": 21607,
-      "views_14d": 24,
-      "unique_visitors_14d": 12,
-      "clones_14d": 9,
-      "unique_cloners_14d": 9,
-      "language": "Python",
-      "created_at": "2025-01-28T14:55:04Z",
-      "updated_at": "2025-11-27T21:43:32Z",
+      "size": 5554,
+      "views_14d": 137,
+      "unique_visitors_14d": 5,
+      "clones_14d": 242,
+      "unique_cloners_14d": 89,
+      "language": "Jupyter Notebook",
+      "created_at": "2024-04-24T22:30:50Z",
+      "updated_at": "2025-12-23T03:41:28Z",
       "topics": [
-        "evaluation-framework",
-        "multimodal-large-language-models",
-        "vlm"
+        "ai",
+        "implementation",
+        "template"
       ]
     },
-    "VectorInstitute/kg-rag": {
-      "repo_id": "VectorInstitute/kg-rag",
-      "name": "kg-rag",
-      "timestamp": "2025-12-22T12:02:51.919317+00:00",
-      "stars": 21,
-      "forks": 10,
+    "VectorInstitute/masksql": {
+      "repo_id": "VectorInstitute/masksql",
+      "name": "masksql",
+      "timestamp": "2025-12-23T15:52:57.230262+00:00",
+      "stars": 1,
+      "forks": 0,
+      "watchers": 0,
+      "open_issues": 3,
+      "size": 6331,
+      "views_14d": 183,
+      "unique_visitors_14d": 5,
+      "clones_14d": 231,
+      "unique_cloners_14d": 71,
+      "language": "Python",
+      "created_at": "2025-10-15T20:14:06Z",
+      "updated_at": "2025-12-18T03:17:33Z",
+      "topics": []
+    },
+    "VectorInstitute/atomgen": {
+      "repo_id": "VectorInstitute/atomgen",
+      "name": "atomgen",
+      "timestamp": "2025-12-23T15:52:58.655636+00:00",
+      "stars": 8,
+      "forks": 1,
       "watchers": 2,
-      "open_issues": 1,
-      "size": 44565,
-      "views_14d": 445,
-      "unique_visitors_14d": 72,
-      "clones_14d": 116,
-      "unique_cloners_14d": 60,
+      "open_issues": 2,
+      "size": 2790,
+      "views_14d": 35,
+      "unique_visitors_14d": 4,
+      "clones_14d": 162,
+      "unique_cloners_14d": 67,
       "language": "Python",
-      "created_at": "2024-12-11T17:22:56Z",
-      "updated_at": "2025-12-18T04:20:12Z",
+      "created_at": "2024-04-11T01:22:34Z",
+      "updated_at": "2025-12-16T22:16:19Z",
       "topics": [
-        "knowledge-graph",
-        "llms",
-        "rag"
+        "ai-for-science",
+        "atomistic-machine-learning",
+        "atomistic-models",
+        "atomistic-simulations",
+        "fine-tuning",
+        "huggingface",
+        "machine-learning",
+        "materials-science",
+        "pretrained-models",
+        "pytorch",
+        "transformers"
       ]
     },
-    "VectorInstitute/recommender-systems": {
-      "repo_id": "VectorInstitute/recommender-systems",
-      "name": "recommender-systems",
-      "timestamp": "2025-12-22T12:02:52.752056+00:00",
-      "stars": 6,
-      "forks": 0,
-      "watchers": 30,
-      "open_issues": 1,
-      "size": 27200,
+    "VectorInstitute/privacy-enhancing-techniques": {
+      "repo_id": "VectorInstitute/privacy-enhancing-techniques",
+      "name": "privacy-enhancing-techniques",
+      "timestamp": "2025-12-23T15:52:59.651775+00:00",
+      "stars": 15,
+      "forks": 9,
+      "watchers": 16,
+      "open_issues": 0,
+      "size": 35253,
       "views_14d": 0,
       "unique_visitors_14d": 0,
-      "clones_14d": 5,
-      "unique_cloners_14d": 5,
+      "clones_14d": 7,
+      "unique_cloners_14d": 7,
       "language": "Jupyter Notebook",
-      "created_at": "2022-06-09T21:10:48Z",
-      "updated_at": "2025-05-13T20:17:43Z",
+      "created_at": "2021-09-28T17:43:56Z",
+      "updated_at": "2025-07-30T00:00:30Z",
       "topics": [
-        "recommender-system"
+        "differential-privacy",
+        "encryption",
+        "federated-learning",
+        "machine-learning",
+        "ml",
+        "privacy"
       ]
     },
-    "VectorInstitute/bias-mitigation-unlearning": {
-      "repo_id": "VectorInstitute/bias-mitigation-unlearning",
-      "name": "bias-mitigation-unlearning",
-      "timestamp": "2025-12-22T12:02:53.374726+00:00",
+    "VectorInstitute/FL4Health": {
+      "repo_id": "VectorInstitute/FL4Health",
+      "name": "FL4Health",
+      "timestamp": "2025-12-23T15:53:00.669147+00:00",
+      "stars": 51,
+      "forks": 16,
+      "watchers": 3,
+      "open_issues": 4,
+      "size": 235211,
+      "views_14d": 343,
+      "unique_visitors_14d": 39,
+      "clones_14d": 221,
+      "unique_cloners_14d": 73,
+      "language": "Python",
+      "created_at": "2022-09-16T12:54:29Z",
+      "updated_at": "2025-12-16T20:57:39Z",
+      "topics": [
+        "deep-learning",
+        "distributed-learning",
+        "federated-learning",
+        "federated-learning-framework",
+        "healthcare",
+        "machine-learning"
+      ]
+    },
+    "VectorInstitute/bias-in-the-picture-benchmark": {
+      "repo_id": "VectorInstitute/bias-in-the-picture-benchmark",
+      "name": "bias-in-the-picture-benchmark",
+      "timestamp": "2025-12-23T15:53:01.720803+00:00",
       "stars": 3,
-      "forks": 2,
-      "watchers": 1,
-      "open_issues": 6,
-      "size": 383,
-      "views_14d": 4,
+      "forks": 0,
+      "watchers": 0,
+      "open_issues": 0,
+      "size": 9705,
+      "views_14d": 3,
       "unique_visitors_14d": 3,
-      "clones_14d": 7,
-      "unique_cloners_14d": 6,
+      "clones_14d": 4,
+      "unique_cloners_14d": 4,
       "language": "Python",
-      "created_at": "2024-10-09T20:05:04Z",
-      "updated_at": "2025-09-01T03:13:59Z",
+      "created_at": "2025-11-21T16:57:41Z",
+      "updated_at": "2025-11-26T21:34:25Z",
       "topics": []
     },
-    "VectorInstitute/linguamark": {
-      "repo_id": "VectorInstitute/linguamark",
-      "name": "linguamark",
-      "timestamp": "2025-12-22T12:02:54.013939+00:00",
-      "stars": 0,
-      "forks": 0,
+    "VectorInstitute/aieng-template-mvp": {
+      "repo_id": "VectorInstitute/aieng-template-mvp",
+      "name": "aieng-template-mvp",
+      "timestamp": "2025-12-23T15:53:02.646476+00:00",
+      "stars": 2,
+      "forks": 1,
+      "watchers": 1,
+      "open_issues": 1,
+      "size": 2604,
+      "views_14d": 99,
+      "unique_visitors_14d": 4,
+      "clones_14d": 631,
+      "unique_cloners_14d": 126,
+      "language": "Python",
+      "created_at": "2025-04-09T15:30:01Z",
+      "updated_at": "2025-12-22T06:49:52Z",
+      "topics": [
+        "mvp",
+        "template"
+      ]
+    },
+    "VectorInstitute/midst-toolkit": {
+      "repo_id": "VectorInstitute/midst-toolkit",
+      "name": "midst-toolkit",
+      "timestamp": "2025-12-23T15:53:03.695580+00:00",
+      "stars": 6,
+      "forks": 1,
       "watchers": 0,
-      "open_issues": 0,
-      "size": 17052,
-      "views_14d": 1,
-      "unique_visitors_14d": 1,
-      "clones_14d": 3,
-      "unique_cloners_14d": 3,
+      "open_issues": 1,
+      "size": 201289,
+      "views_14d": 594,
+      "unique_visitors_14d": 16,
+      "clones_14d": 346,
+      "unique_cloners_14d": 97,
       "language": "Python",
-      "created_at": "2025-06-09T17:34:32Z",
-      "updated_at": "2025-11-25T20:14:47Z",
+      "created_at": "2025-06-13T13:37:34Z",
+      "updated_at": "2025-12-17T19:50:32Z",
       "topics": []
     },
     "VectorInstitute/cyclops": {
       "repo_id": "VectorInstitute/cyclops",
       "name": "cyclops",
-      "timestamp": "2025-12-22T12:02:54.695987+00:00",
+      "timestamp": "2025-12-23T15:53:05.327997+00:00",
       "stars": 87,
       "forks": 14,
       "watchers": 8,
@@ -168,8 +340,8 @@
       "size": 27256,
       "views_14d": 31,
       "unique_visitors_14d": 24,
-      "clones_14d": 359,
-      "unique_cloners_14d": 69,
+      "clones_14d": 355,
+      "unique_cloners_14d": 70,
       "language": "Python",
       "created_at": "2022-02-21T21:15:08Z",
       "updated_at": "2025-10-16T06:37:02Z",
@@ -193,259 +365,165 @@
         "physionet"
       ]
     },
-    "VectorInstitute/finetuning-and-alignment": {
-      "repo_id": "VectorInstitute/finetuning-and-alignment",
-      "name": "finetuning-and-alignment",
-      "timestamp": "2025-12-22T12:02:55.362524+00:00",
-      "stars": 11,
-      "forks": 3,
-      "watchers": 30,
-      "open_issues": 0,
-      "size": 27777,
-      "views_14d": 1,
-      "unique_visitors_14d": 1,
-      "clones_14d": 12,
-      "unique_cloners_14d": 10,
-      "language": "Jupyter Notebook",
-      "created_at": "2024-05-14T03:18:04Z",
-      "updated_at": "2025-11-27T02:38:26Z",
-      "topics": [
-        "alignment",
-        "fine-tuning"
-      ]
-    },
-    "VectorInstitute/diffusion-models": {
-      "repo_id": "VectorInstitute/diffusion-models",
-      "name": "diffusion-models",
-      "timestamp": "2025-12-22T12:02:56.030374+00:00",
-      "stars": 5,
+    "VectorInstitute/aieng-template-poetry": {
+      "repo_id": "VectorInstitute/aieng-template-poetry",
+      "name": "aieng-template-poetry",
+      "timestamp": "2025-12-23T15:53:06.417960+00:00",
+      "stars": 4,
       "forks": 0,
-      "watchers": 10,
-      "open_issues": 1,
-      "size": 272452,
-      "views_14d": 4,
-      "unique_visitors_14d": 4,
+      "watchers": 7,
+      "open_issues": 6,
+      "size": 831,
+      "views_14d": 17,
+      "unique_visitors_14d": 5,
       "clones_14d": 12,
       "unique_cloners_14d": 8,
-      "language": "Jupyter Notebook",
-      "created_at": "2024-06-12T17:52:14Z",
-      "updated_at": "2025-12-01T17:38:22Z",
-      "topics": [
-        "diffusion-models",
-        "synthetic-data"
-      ]
+      "language": "Python",
+      "created_at": "2022-03-14T14:55:29Z",
+      "updated_at": "2025-05-15T22:16:23Z",
+      "topics": []
     },
-    "VectorInstitute/odyssey": {
-      "repo_id": "VectorInstitute/odyssey",
-      "name": "odyssey",
-      "timestamp": "2025-12-22T12:02:56.694446+00:00",
-      "stars": 48,
-      "forks": 14,
-      "watchers": 4,
-      "open_issues": 9,
-      "size": 105588,
-      "views_14d": 219,
-      "unique_visitors_14d": 47,
-      "clones_14d": 107,
-      "unique_cloners_14d": 57,
+    "VectorInstitute/vbll": {
+      "repo_id": "VectorInstitute/vbll",
+      "name": "vbll",
+      "timestamp": "2025-12-23T15:53:07.389330+00:00",
+      "stars": 79,
+      "forks": 8,
+      "watchers": 2,
+      "open_issues": 4,
+      "size": 551,
+      "views_14d": 179,
+      "unique_visitors_14d": 36,
+      "clones_14d": 21,
+      "unique_cloners_14d": 18,
       "language": "Python",
-      "created_at": "2023-12-01T15:46:32Z",
-      "updated_at": "2025-12-19T10:03:46Z",
-      "topics": [
-        "electronic-health-record",
-        "foundation-models",
-        "healthcare",
-        "machine-learning",
-        "mimic-iv",
-        "state-space-models",
-        "transformers"
-      ]
+      "created_at": "2023-10-11T15:26:23Z",
+      "updated_at": "2025-12-22T01:59:04Z",
+      "topics": []
     },
-    "VectorInstitute/crisp-nam": {
-      "repo_id": "VectorInstitute/crisp-nam",
-      "name": "crisp-nam",
-      "timestamp": "2025-12-22T12:02:57.276836+00:00",
-      "stars": 2,
+    "VectorInstitute/aieng-template-blog": {
+      "repo_id": "VectorInstitute/aieng-template-blog",
+      "name": "aieng-template-blog",
+      "timestamp": "2025-12-23T15:53:08.440350+00:00",
+      "stars": 3,
       "forks": 0,
-      "watchers": 0,
+      "watchers": 1,
       "open_issues": 0,
-      "size": 7170,
-      "views_14d": 31,
-      "unique_visitors_14d": 4,
-      "clones_14d": 4,
-      "unique_cloners_14d": 4,
-      "language": "Python",
-      "created_at": "2025-05-22T15:49:19Z",
-      "updated_at": "2025-11-25T20:44:42Z",
+      "size": 1052,
+      "views_14d": 133,
+      "unique_visitors_14d": 6,
+      "clones_14d": 398,
+      "unique_cloners_14d": 127,
+      "language": "JavaScript",
+      "created_at": "2025-01-23T16:19:25Z",
+      "updated_at": "2025-12-23T00:19:14Z",
       "topics": []
     },
-    "VectorInstitute/FL4Health": {
-      "repo_id": "VectorInstitute/FL4Health",
-      "name": "FL4Health",
-      "timestamp": "2025-12-22T12:02:57.888092+00:00",
-      "stars": 51,
-      "forks": 16,
-      "watchers": 3,
-      "open_issues": 3,
-      "size": 235209,
-      "views_14d": 330,
-      "unique_visitors_14d": 38,
-      "clones_14d": 231,
-      "unique_cloners_14d": 77,
-      "language": "Python",
-      "created_at": "2022-09-16T12:54:29Z",
-      "updated_at": "2025-12-16T20:57:39Z",
+    "vectorinstitute/retrieval-augmented-generation": {
+      "repo_id": "vectorinstitute/retrieval-augmented-generation",
+      "name": "retrieval-augmented-generation",
+      "timestamp": "2025-12-23T15:53:09.340353+00:00",
+      "stars": 30,
+      "forks": 21,
+      "watchers": 24,
+      "open_issues": 1,
+      "size": 49324,
+      "views_14d": 61,
+      "unique_visitors_14d": 21,
+      "clones_14d": 54,
+      "unique_cloners_14d": 31,
+      "language": "Jupyter Notebook",
+      "created_at": "2023-11-30T19:17:30Z",
+      "updated_at": "2025-12-15T14:42:58Z",
       "topics": [
-        "deep-learning",
-        "distributed-learning",
-        "federated-learning",
-        "federated-learning-framework",
-        "healthcare",
-        "machine-learning"
+        "rag",
+        "retrieval-augmented-generation"
       ]
     },
-    "VectorInstitute/mmlearn": {
-      "repo_id": "VectorInstitute/mmlearn",
-      "name": "mmlearn",
-      "timestamp": "2025-12-22T12:02:58.625883+00:00",
-      "stars": 19,
-      "forks": 3,
-      "watchers": 4,
-      "open_issues": 6,
-      "size": 5302,
-      "views_14d": 45,
-      "unique_visitors_14d": 13,
-      "clones_14d": 143,
-      "unique_cloners_14d": 69,
+    "VectorInstitute/kg-rag": {
+      "repo_id": "VectorInstitute/kg-rag",
+      "name": "kg-rag",
+      "timestamp": "2025-12-23T15:53:10.317199+00:00",
+      "stars": 22,
+      "forks": 10,
+      "watchers": 2,
+      "open_issues": 1,
+      "size": 44565,
+      "views_14d": 448,
+      "unique_visitors_14d": 69,
+      "clones_14d": 118,
+      "unique_cloners_14d": 59,
       "language": "Python",
-      "created_at": "2024-08-07T18:50:11Z",
-      "updated_at": "2025-12-16T22:24:53Z",
+      "created_at": "2024-12-11T17:22:56Z",
+      "updated_at": "2025-12-22T12:07:19Z",
       "topics": [
-        "clip",
-        "contrastive-learning",
-        "i-jepa",
-        "multi-task-learning",
-        "multimodal-learning",
-        "zero-shot-classification",
-        "zero-shot-retrieval"
+        "knowledge-graph",
+        "llms",
+        "rag"
       ]
     },
-    "VectorInstitute/atomgen": {
-      "repo_id": "VectorInstitute/atomgen",
-      "name": "atomgen",
-      "timestamp": "2025-12-22T12:02:59.227543+00:00",
-      "stars": 8,
-      "forks": 1,
-      "watchers": 2,
-      "open_issues": 0,
-      "size": 2639,
-      "views_14d": 43,
-      "unique_visitors_14d": 5,
-      "clones_14d": 185,
-      "unique_cloners_14d": 77,
+    "VectorInstitute/bias-mitigation-unlearning": {
+      "repo_id": "VectorInstitute/bias-mitigation-unlearning",
+      "name": "bias-mitigation-unlearning",
+      "timestamp": "2025-12-23T15:53:11.359562+00:00",
+      "stars": 3,
+      "forks": 2,
+      "watchers": 1,
+      "open_issues": 6,
+      "size": 383,
+      "views_14d": 4,
+      "unique_visitors_14d": 3,
+      "clones_14d": 7,
+      "unique_cloners_14d": 6,
       "language": "Python",
-      "created_at": "2024-04-11T01:22:34Z",
-      "updated_at": "2025-12-16T22:16:19Z",
-      "topics": [
-        "ai-for-science",
-        "atomistic-machine-learning",
-        "atomistic-models",
-        "atomistic-simulations",
-        "fine-tuning",
-        "huggingface",
-        "machine-learning",
-        "materials-science",
-        "pretrained-models",
-        "pytorch",
-        "transformers"
-      ]
+      "created_at": "2024-10-09T20:05:04Z",
+      "updated_at": "2025-09-01T03:13:59Z",
+      "topics": []
     },
     "VectorInstitute/FLorist": {
       "repo_id": "VectorInstitute/FLorist",
       "name": "FLorist",
-      "timestamp": "2025-12-22T12:02:59.941858+00:00",
+      "timestamp": "2025-12-23T15:53:12.385215+00:00",
       "stars": 10,
       "forks": 1,
       "watchers": 4,
       "open_issues": 2,
-      "size": 6064,
+      "size": 6069,
       "views_14d": 2,
       "unique_visitors_14d": 2,
-      "clones_14d": 212,
-      "unique_cloners_14d": 85,
+      "clones_14d": 234,
+      "unique_cloners_14d": 92,
       "language": "CSS",
       "created_at": "2024-01-29T19:34:13Z",
-      "updated_at": "2025-12-15T20:01:16Z",
+      "updated_at": "2025-12-22T20:06:52Z",
       "topics": []
     },
-    "VectorInstitute/privacy-enhancing-techniques": {
-      "repo_id": "VectorInstitute/privacy-enhancing-techniques",
-      "name": "privacy-enhancing-techniques",
-      "timestamp": "2025-12-22T12:03:00.637356+00:00",
-      "stars": 15,
-      "forks": 9,
-      "watchers": 16,
-      "open_issues": 0,
-      "size": 35253,
-      "views_14d": 0,
-      "unique_visitors_14d": 0,
-      "clones_14d": 8,
-      "unique_cloners_14d": 8,
-      "language": "Jupyter Notebook",
-      "created_at": "2021-09-28T17:43:56Z",
-      "updated_at": "2025-07-30T00:00:30Z",
-      "topics": [
-        "differential-privacy",
-        "encryption",
-        "federated-learning",
-        "machine-learning",
-        "ml",
-        "privacy"
-      ]
-    },
-    "VectorInstitute/ai-deployment": {
-      "repo_id": "VectorInstitute/ai-deployment",
-      "name": "ai-deployment",
-      "timestamp": "2025-12-22T12:03:01.331583+00:00",
-      "stars": 8,
-      "forks": 29,
-      "watchers": 4,
-      "open_issues": 0,
-      "size": 18502,
-      "views_14d": 4,
-      "unique_visitors_14d": 4,
-      "clones_14d": 10,
-      "unique_cloners_14d": 9,
-      "language": "Python",
-      "created_at": "2024-06-03T19:08:04Z",
-      "updated_at": "2025-11-27T02:32:45Z",
-      "topics": [
-        "ai",
-        "deployment"
-      ]
-    },
-    "VectorInstitute/pmc-data-extraction": {
-      "repo_id": "VectorInstitute/pmc-data-extraction",
-      "name": "pmc-data-extraction",
-      "timestamp": "2025-12-22T12:03:02.000786+00:00",
-      "stars": 14,
+    "VectorInstitute/humanibench": {
+      "repo_id": "VectorInstitute/humanibench",
+      "name": "humanibench",
+      "timestamp": "2025-12-23T15:53:13.401822+00:00",
+      "stars": 6,
       "forks": 1,
       "watchers": 1,
-      "open_issues": 6,
-      "size": 13482,
-      "views_14d": 390,
-      "unique_visitors_14d": 19,
-      "clones_14d": 12,
+      "open_issues": 0,
+      "size": 21607,
+      "views_14d": 45,
+      "unique_visitors_14d": 11,
+      "clones_14d": 11,
       "unique_cloners_14d": 11,
-      "language": "Jupyter Notebook",
-      "created_at": "2024-09-12T17:32:48Z",
-      "updated_at": "2025-12-19T18:38:11Z",
-      "topics": []
+      "language": "Python",
+      "created_at": "2025-01-28T14:55:04Z",
+      "updated_at": "2025-11-27T21:43:32Z",
+      "topics": [
+        "evaluation-framework",
+        "multimodal-large-language-models",
+        "vlm"
+      ]
     },
     "VectorInstitute/shared-encoder": {
       "repo_id": "VectorInstitute/shared-encoder",
       "name": "shared-encoder",
-      "timestamp": "2025-12-22T12:03:02.718752+00:00",
+      "timestamp": "2025-12-23T15:53:14.410096+00:00",
       "stars": 9,
       "forks": 1,
       "watchers": 4,
@@ -453,8 +531,8 @@
       "size": 157,
       "views_14d": 9,
       "unique_visitors_14d": 7,
-      "clones_14d": 10,
-      "unique_cloners_14d": 9,
+      "clones_14d": 11,
+      "unique_cloners_14d": 10,
       "language": "Python",
       "created_at": "2025-02-21T17:04:07Z",
       "updated_at": "2025-10-02T02:00:56Z",
@@ -467,40 +545,19 @@
         "shared-encoder"
       ]
     },
-    "VectorInstitute/HV-Ai-C": {
-      "repo_id": "VectorInstitute/HV-Ai-C",
-      "name": "HV-Ai-C",
-      "timestamp": "2025-12-22T12:03:03.320159+00:00",
-      "stars": 74,
-      "forks": 22,
-      "watchers": 6,
-      "open_issues": 1,
-      "size": 223,
-      "views_14d": 70,
-      "unique_visitors_14d": 24,
-      "clones_14d": 18,
-      "unique_cloners_14d": 16,
-      "language": "Python",
-      "created_at": "2022-03-03T16:55:04Z",
-      "updated_at": "2025-12-03T19:07:08Z",
-      "topics": [
-        "hvac-control",
-        "reinforcement-learning"
-      ]
-    },
     "VectorInstitute/interpretability": {
       "repo_id": "VectorInstitute/interpretability",
       "name": "interpretability",
-      "timestamp": "2025-12-22T12:03:03.879240+00:00",
+      "timestamp": "2025-12-23T15:53:15.383743+00:00",
       "stars": 5,
       "forks": 0,
       "watchers": 7,
       "open_issues": 1,
       "size": 552941,
-      "views_14d": 31,
-      "unique_visitors_14d": 6,
-      "clones_14d": 26,
-      "unique_cloners_14d": 15,
+      "views_14d": 13,
+      "unique_visitors_14d": 5,
+      "clones_14d": 13,
+      "unique_cloners_14d": 9,
       "language": "Jupyter Notebook",
       "created_at": "2024-09-19T15:22:45Z",
       "updated_at": "2025-12-08T20:21:38Z",
@@ -510,42 +567,40 @@
         "machine-learning"
       ]
     },
-    "VectorInstitute/self-supervised-learning": {
-      "repo_id": "VectorInstitute/self-supervised-learning",
-      "name": "self-supervised-learning",
-      "timestamp": "2025-12-22T12:03:04.608234+00:00",
-      "stars": 3,
+    "VectorInstitute/diffusion-models": {
+      "repo_id": "VectorInstitute/diffusion-models",
+      "name": "diffusion-models",
+      "timestamp": "2025-12-23T15:53:16.421367+00:00",
+      "stars": 5,
       "forks": 0,
-      "watchers": 18,
-      "open_issues": 0,
-      "size": 84026,
-      "views_14d": 3,
-      "unique_visitors_14d": 3,
-      "clones_14d": 3,
-      "unique_cloners_14d": 3,
+      "watchers": 10,
+      "open_issues": 1,
+      "size": 272452,
+      "views_14d": 4,
+      "unique_visitors_14d": 4,
+      "clones_14d": 14,
+      "unique_cloners_14d": 8,
       "language": "Jupyter Notebook",
-      "created_at": "2023-08-17T15:25:42Z",
-      "updated_at": "2025-11-26T21:28:48Z",
+      "created_at": "2024-06-12T17:52:14Z",
+      "updated_at": "2025-12-01T17:38:22Z",
       "topics": [
-        "contrastive-learning",
-        "masked-modelling",
-        "self-distillation",
-        "self-supervised-learning"
+        "diffusion-models",
+        "synthetic-data"
       ]
     },
     "VectorInstitute/fed-rag": {
       "repo_id": "VectorInstitute/fed-rag",
       "name": "fed-rag",
-      "timestamp": "2025-12-22T12:03:05.347010+00:00",
+      "timestamp": "2025-12-23T15:53:17.399437+00:00",
       "stars": 137,
       "forks": 26,
       "watchers": 6,
       "open_issues": 51,
       "size": 14216,
-      "views_14d": 112,
+      "views_14d": 140,
       "unique_visitors_14d": 49,
-      "clones_14d": 306,
-      "unique_cloners_14d": 85,
+      "clones_14d": 299,
+      "unique_cloners_14d": 86,
       "language": "Python",
       "created_at": "2025-01-17T20:04:22Z",
       "updated_at": "2025-12-19T23:21:22Z",
@@ -557,28 +612,28 @@
         "rag"
       ]
     },
-    "VectorInstitute/midst-toolkit": {
-      "repo_id": "VectorInstitute/midst-toolkit",
-      "name": "midst-toolkit",
-      "timestamp": "2025-12-22T12:03:06.051070+00:00",
-      "stars": 6,
+    "VectorInstitute/pmc-data-extraction": {
+      "repo_id": "VectorInstitute/pmc-data-extraction",
+      "name": "pmc-data-extraction",
+      "timestamp": "2025-12-23T15:53:18.349914+00:00",
+      "stars": 14,
       "forks": 1,
-      "watchers": 0,
-      "open_issues": 1,
-      "size": 201289,
-      "views_14d": 647,
+      "watchers": 1,
+      "open_issues": 6,
+      "size": 13482,
+      "views_14d": 283,
       "unique_visitors_14d": 17,
-      "clones_14d": 395,
-      "unique_cloners_14d": 112,
-      "language": "Python",
-      "created_at": "2025-06-13T13:37:34Z",
-      "updated_at": "2025-12-17T19:50:32Z",
+      "clones_14d": 11,
+      "unique_cloners_14d": 10,
+      "language": "Jupyter Notebook",
+      "created_at": "2024-09-12T17:32:48Z",
+      "updated_at": "2025-12-19T18:38:11Z",
       "topics": []
     },
     "VectorInstitute/anomaly-detection": {
       "repo_id": "VectorInstitute/anomaly-detection",
       "name": "anomaly-detection",
-      "timestamp": "2025-12-22T12:03:06.762512+00:00",
+      "timestamp": "2025-12-23T15:53:19.356481+00:00",
       "stars": 8,
       "forks": 0,
       "watchers": 19,
@@ -586,8 +641,8 @@
       "size": 15604,
       "views_14d": 39,
       "unique_visitors_14d": 14,
-      "clones_14d": 4,
-      "unique_cloners_14d": 4,
+      "clones_14d": 5,
+      "unique_cloners_14d": 5,
       "language": "Jupyter Notebook",
       "created_at": "2023-03-20T16:43:29Z",
       "updated_at": "2025-07-29T21:42:49Z",
@@ -595,86 +650,149 @@
         "anomaly-detection"
       ]
     },
-    "VectorInstitute/masksql": {
-      "repo_id": "VectorInstitute/masksql",
-      "name": "masksql",
-      "timestamp": "2025-12-22T12:03:07.542904+00:00",
-      "stars": 1,
-      "forks": 0,
-      "watchers": 0,
-      "open_issues": 3,
-      "size": 6331,
-      "views_14d": 183,
-      "unique_visitors_14d": 5,
-      "clones_14d": 231,
-      "unique_cloners_14d": 71,
-      "language": "Python",
-      "created_at": "2025-10-15T20:14:06Z",
-      "updated_at": "2025-12-18T03:17:33Z",
-      "topics": []
-    },
-    "VectorInstitute/vbll": {
-      "repo_id": "VectorInstitute/vbll",
-      "name": "vbll",
-      "timestamp": "2025-12-22T12:03:08.241459+00:00",
-      "stars": 79,
-      "forks": 8,
-      "watchers": 2,
-      "open_issues": 4,
-      "size": 551,
-      "views_14d": 198,
-      "unique_visitors_14d": 37,
-      "clones_14d": 20,
-      "unique_cloners_14d": 17,
-      "language": "Python",
-      "created_at": "2023-10-11T15:26:23Z",
-      "updated_at": "2025-12-22T01:59:04Z",
-      "topics": []
-    },
-    "VectorInstitute/vector-inference": {
-      "repo_id": "VectorInstitute/vector-inference",
-      "name": "vector-inference",
-      "timestamp": "2025-12-22T12:03:08.915887+00:00",
-      "stars": 87,
-      "forks": 12,
-      "watchers": 7,
-      "open_issues": 9,
-      "size": 4915,
-      "views_14d": 462,
-      "unique_visitors_14d": 90,
-      "clones_14d": 215,
-      "unique_cloners_14d": 92,
-      "language": "Python",
-      "created_at": "2024-03-06T01:36:48Z",
-      "updated_at": "2025-12-16T00:45:27Z",
+    "VectorInstitute/finetuning-and-alignment": {
+      "repo_id": "VectorInstitute/finetuning-and-alignment",
+      "name": "finetuning-and-alignment",
+      "timestamp": "2025-12-23T15:53:20.334294+00:00",
+      "stars": 11,
+      "forks": 3,
+      "watchers": 30,
+      "open_issues": 0,
+      "size": 27777,
+      "views_14d": 1,
+      "unique_visitors_14d": 1,
+      "clones_14d": 11,
+      "unique_cloners_14d": 9,
+      "language": "Jupyter Notebook",
+      "created_at": "2024-05-14T03:18:04Z",
+      "updated_at": "2025-11-27T02:38:26Z",
       "topics": [
-        "inference",
-        "llm",
-        "llm-inference",
-        "reward-modeling",
-        "text-embedding",
-        "vllm",
-        "vlm"
+        "alignment",
+        "fine-tuning"
       ]
     },
     "VectorInstitute/fair-sense-ai": {
       "repo_id": "VectorInstitute/fair-sense-ai",
       "name": "fair-sense-ai",
-      "timestamp": "2025-12-22T12:03:09.535058+00:00",
+      "timestamp": "2025-12-23T15:53:21.457600+00:00",
       "stars": 6,
       "forks": 3,
       "watchers": 0,
       "open_issues": 0,
       "size": 13906,
-      "views_14d": 54,
-      "unique_visitors_14d": 13,
-      "clones_14d": 28,
-      "unique_cloners_14d": 23,
+      "views_14d": 51,
+      "unique_visitors_14d": 10,
+      "clones_14d": 26,
+      "unique_cloners_14d": 21,
       "language": "Python",
       "created_at": "2025-01-08T20:10:48Z",
       "updated_at": "2025-12-04T03:29:22Z",
       "topics": []
+    },
+    "VectorInstitute/HV-Ai-C": {
+      "repo_id": "VectorInstitute/HV-Ai-C",
+      "name": "HV-Ai-C",
+      "timestamp": "2025-12-23T15:53:22.417700+00:00",
+      "stars": 74,
+      "forks": 22,
+      "watchers": 6,
+      "open_issues": 1,
+      "size": 223,
+      "views_14d": 41,
+      "unique_visitors_14d": 23,
+      "clones_14d": 16,
+      "unique_cloners_14d": 14,
+      "language": "Python",
+      "created_at": "2022-03-03T16:55:04Z",
+      "updated_at": "2025-12-03T19:07:08Z",
+      "topics": [
+        "hvac-control",
+        "reinforcement-learning"
+      ]
+    },
+    "VectorInstitute/odyssey": {
+      "repo_id": "VectorInstitute/odyssey",
+      "name": "odyssey",
+      "timestamp": "2025-12-23T15:53:23.431146+00:00",
+      "stars": 48,
+      "forks": 14,
+      "watchers": 4,
+      "open_issues": 9,
+      "size": 105588,
+      "views_14d": 190,
+      "unique_visitors_14d": 48,
+      "clones_14d": 57,
+      "unique_cloners_14d": 32,
+      "language": "Python",
+      "created_at": "2023-12-01T15:46:32Z",
+      "updated_at": "2025-12-19T10:03:46Z",
+      "topics": [
+        "electronic-health-record",
+        "foundation-models",
+        "healthcare",
+        "machine-learning",
+        "mimic-iv",
+        "state-space-models",
+        "transformers"
+      ]
+    },
+    "VectorInstitute/mcp-goodnews": {
+      "repo_id": "VectorInstitute/mcp-goodnews",
+      "name": "mcp-goodnews",
+      "timestamp": "2025-12-23T15:53:24.335167+00:00",
+      "stars": 44,
+      "forks": 9,
+      "watchers": 0,
+      "open_issues": 1,
+      "size": 101,
+      "views_14d": 45,
+      "unique_visitors_14d": 14,
+      "clones_14d": 44,
+      "unique_cloners_14d": 33,
+      "language": "Python",
+      "created_at": "2025-03-18T18:06:25Z",
+      "updated_at": "2025-11-26T21:32:12Z",
+      "topics": []
+    },
+    "VectorInstitute/linguamark": {
+      "repo_id": "VectorInstitute/linguamark",
+      "name": "linguamark",
+      "timestamp": "2025-12-23T15:53:25.326595+00:00",
+      "stars": 0,
+      "forks": 0,
+      "watchers": 0,
+      "open_issues": 0,
+      "size": 17052,
+      "views_14d": 1,
+      "unique_visitors_14d": 1,
+      "clones_14d": 3,
+      "unique_cloners_14d": 3,
+      "language": "Python",
+      "created_at": "2025-06-09T17:34:32Z",
+      "updated_at": "2025-11-25T20:14:47Z",
+      "topics": []
+    },
+    "VectorInstitute/ai-deployment": {
+      "repo_id": "VectorInstitute/ai-deployment",
+      "name": "ai-deployment",
+      "timestamp": "2025-12-23T15:53:26.312750+00:00",
+      "stars": 8,
+      "forks": 29,
+      "watchers": 4,
+      "open_issues": 0,
+      "size": 18502,
+      "views_14d": 2,
+      "unique_visitors_14d": 2,
+      "clones_14d": 10,
+      "unique_cloners_14d": 9,
+      "language": "Python",
+      "created_at": "2024-06-03T19:08:04Z",
+      "updated_at": "2025-11-27T02:32:45Z",
+      "topics": [
+        "ai",
+        "deployment"
+      ]
     }
   },
-  "last_updated": "2025-12-22T12:03:10.183301+00:00"
-}
\ No newline at end of file
+  "last_updated": "2025-12-23T15:53:27.294836+00:00"
+}
diff --git a/catalog/public/data/github_metrics_history.json b/catalog/public/data/github_metrics_history.json
index 98224db..2bf88b9 100644
--- a/catalog/public/data/github_metrics_history.json
+++ b/catalog/public/data/github_metrics_history.json
@@ -236,6 +236,24 @@
           "created_at": "2025-06-13T13:37:34Z",
           "updated_at": "2025-12-17T19:50:32Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/midst-toolkit",
+          "name": "midst-toolkit",
+          "timestamp": "2025-12-23T15:53:03.695580+00:00",
+          "stars": 6,
+          "forks": 1,
+          "watchers": 0,
+          "open_issues": 1,
+          "size": 201289,
+          "views_14d": 594,
+          "unique_visitors_14d": 16,
+          "clones_14d": 346,
+          "unique_cloners_14d": 97,
+          "language": "Python",
+          "created_at": "2025-06-13T13:37:34Z",
+          "updated_at": "2025-12-17T19:50:32Z",
+          "topics": []
         }
       ]
     },
@@ -631,6 +649,36 @@
             "pytorch",
             "transformers"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/atomgen",
+          "name": "atomgen",
+          "timestamp": "2025-12-23T15:52:58.655636+00:00",
+          "stars": 8,
+          "forks": 1,
+          "watchers": 2,
+          "open_issues": 2,
+          "size": 2790,
+          "views_14d": 35,
+          "unique_visitors_14d": 4,
+          "clones_14d": 162,
+          "unique_cloners_14d": 67,
+          "language": "Python",
+          "created_at": "2024-04-11T01:22:34Z",
+          "updated_at": "2025-12-16T22:16:19Z",
+          "topics": [
+            "ai-for-science",
+            "atomistic-machine-learning",
+            "atomistic-models",
+            "atomistic-simulations",
+            "fine-tuning",
+            "huggingface",
+            "machine-learning",
+            "materials-science",
+            "pretrained-models",
+            "pytorch",
+            "transformers"
+          ]
         }
       ]
     },
@@ -896,6 +944,26 @@
           "topics": [
             "anomaly-detection"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/anomaly-detection",
+          "name": "anomaly-detection",
+          "timestamp": "2025-12-23T15:53:19.356481+00:00",
+          "stars": 8,
+          "forks": 0,
+          "watchers": 19,
+          "open_issues": 0,
+          "size": 15604,
+          "views_14d": 39,
+          "unique_visitors_14d": 14,
+          "clones_14d": 5,
+          "unique_cloners_14d": 5,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-03-20T16:43:29Z",
+          "updated_at": "2025-07-29T21:42:49Z",
+          "topics": [
+            "anomaly-detection"
+          ]
         }
       ]
     },
@@ -1369,6 +1437,42 @@
             "omop-cdm",
             "physionet"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/cyclops",
+          "name": "cyclops",
+          "timestamp": "2025-12-23T15:53:05.327997+00:00",
+          "stars": 87,
+          "forks": 14,
+          "watchers": 8,
+          "open_issues": 20,
+          "size": 27256,
+          "views_14d": 31,
+          "unique_visitors_14d": 24,
+          "clones_14d": 355,
+          "unique_cloners_14d": 70,
+          "language": "Python",
+          "created_at": "2022-02-21T21:15:08Z",
+          "updated_at": "2025-10-16T06:37:02Z",
+          "topics": [
+            "clinical-data",
+            "clinical-decision-support",
+            "clinical-research",
+            "data-drift",
+            "deep-learning",
+            "drift-detection",
+            "eicu-crd",
+            "electronic-health-record",
+            "electronic-medical-record",
+            "evaluation",
+            "healthcare",
+            "machine-learning",
+            "mimic-iii",
+            "mimic-iv",
+            "model-monitoring",
+            "omop-cdm",
+            "physionet"
+          ]
         }
       ]
     },
@@ -1634,6 +1738,26 @@
           "topics": [
             "recommender-system"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/recommender-systems",
+          "name": "recommender-systems",
+          "timestamp": "2025-12-23T15:52:51.296878+00:00",
+          "stars": 6,
+          "forks": 0,
+          "watchers": 30,
+          "open_issues": 1,
+          "size": 27200,
+          "views_14d": 0,
+          "unique_visitors_14d": 0,
+          "clones_14d": 6,
+          "unique_cloners_14d": 6,
+          "language": "Jupyter Notebook",
+          "created_at": "2022-06-09T21:10:48Z",
+          "updated_at": "2025-05-13T20:17:43Z",
+          "topics": [
+            "recommender-system"
+          ]
         }
       ]
     },
@@ -1951,6 +2075,30 @@
             "machine-learning",
             "rag"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/fed-rag",
+          "name": "fed-rag",
+          "timestamp": "2025-12-23T15:53:17.399437+00:00",
+          "stars": 137,
+          "forks": 26,
+          "watchers": 6,
+          "open_issues": 51,
+          "size": 14216,
+          "views_14d": 140,
+          "unique_visitors_14d": 49,
+          "clones_14d": 299,
+          "unique_cloners_14d": 86,
+          "language": "Python",
+          "created_at": "2025-01-17T20:04:22Z",
+          "updated_at": "2025-12-19T23:21:22Z",
+          "topics": [
+            "deep-learning",
+            "federated-learning",
+            "llms",
+            "machine-learning",
+            "rag"
+          ]
         }
       ]
     },
@@ -2294,6 +2442,32 @@
             "state-space-models",
             "transformers"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/odyssey",
+          "name": "odyssey",
+          "timestamp": "2025-12-23T15:53:23.431146+00:00",
+          "stars": 48,
+          "forks": 14,
+          "watchers": 4,
+          "open_issues": 9,
+          "size": 105588,
+          "views_14d": 190,
+          "unique_visitors_14d": 48,
+          "clones_14d": 57,
+          "unique_cloners_14d": 32,
+          "language": "Python",
+          "created_at": "2023-12-01T15:46:32Z",
+          "updated_at": "2025-12-19T10:03:46Z",
+          "topics": [
+            "electronic-health-record",
+            "foundation-models",
+            "healthcare",
+            "machine-learning",
+            "mimic-iv",
+            "state-space-models",
+            "transformers"
+          ]
         }
       ]
     },
@@ -2624,6 +2798,31 @@
             "quilt",
             "shared-encoder"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/shared-encoder",
+          "name": "shared-encoder",
+          "timestamp": "2025-12-23T15:53:14.410096+00:00",
+          "stars": 9,
+          "forks": 1,
+          "watchers": 4,
+          "open_issues": 3,
+          "size": 157,
+          "views_14d": 9,
+          "unique_visitors_14d": 7,
+          "clones_14d": 11,
+          "unique_cloners_14d": 10,
+          "language": "Python",
+          "created_at": "2025-02-21T17:04:07Z",
+          "updated_at": "2025-10-02T02:00:56Z",
+          "topics": [
+            "clip",
+            "mimic-cxr",
+            "multimodal",
+            "multimodal-learning",
+            "quilt",
+            "shared-encoder"
+          ]
         }
       ]
     },
@@ -2954,6 +3153,31 @@
             "ml",
             "privacy"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/privacy-enhancing-techniques",
+          "name": "privacy-enhancing-techniques",
+          "timestamp": "2025-12-23T15:52:59.651775+00:00",
+          "stars": 15,
+          "forks": 9,
+          "watchers": 16,
+          "open_issues": 0,
+          "size": 35253,
+          "views_14d": 0,
+          "unique_visitors_14d": 0,
+          "clones_14d": 7,
+          "unique_cloners_14d": 7,
+          "language": "Jupyter Notebook",
+          "created_at": "2021-09-28T17:43:56Z",
+          "updated_at": "2025-07-30T00:00:30Z",
+          "topics": [
+            "differential-privacy",
+            "encryption",
+            "federated-learning",
+            "machine-learning",
+            "ml",
+            "privacy"
+          ]
         }
       ]
     },
@@ -3258,6 +3482,29 @@
             "self-distillation",
             "self-supervised-learning"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/self-supervised-learning",
+          "name": "self-supervised-learning",
+          "timestamp": "2025-12-23T15:52:55.204482+00:00",
+          "stars": 3,
+          "forks": 0,
+          "watchers": 18,
+          "open_issues": 0,
+          "size": 84026,
+          "views_14d": 3,
+          "unique_visitors_14d": 3,
+          "clones_14d": 3,
+          "unique_cloners_14d": 3,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-08-17T15:25:42Z",
+          "updated_at": "2025-11-26T21:28:48Z",
+          "topics": [
+            "contrastive-learning",
+            "masked-modelling",
+            "self-distillation",
+            "self-supervised-learning"
+          ]
         }
       ]
     },
@@ -3497,6 +3744,24 @@
           "created_at": "2024-01-29T19:34:13Z",
           "updated_at": "2025-12-15T20:01:16Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/FLorist",
+          "name": "FLorist",
+          "timestamp": "2025-12-23T15:53:12.385215+00:00",
+          "stars": 10,
+          "forks": 1,
+          "watchers": 4,
+          "open_issues": 2,
+          "size": 6069,
+          "views_14d": 2,
+          "unique_visitors_14d": 2,
+          "clones_14d": 234,
+          "unique_cloners_14d": 92,
+          "language": "CSS",
+          "created_at": "2024-01-29T19:34:13Z",
+          "updated_at": "2025-12-22T20:06:52Z",
+          "topics": []
         }
       ]
     },
@@ -3736,22 +4001,40 @@
           "created_at": "2025-11-21T16:57:41Z",
           "updated_at": "2025-11-26T21:34:25Z",
           "topics": []
-        }
-      ]
-    },
-    "VectorInstitute/kg-rag": {
-      "name": "kg-rag",
-      "snapshots": [
+        },
         {
-          "repo_id": "VectorInstitute/kg-rag",
-          "name": "kg-rag",
-          "timestamp": "2025-11-25T19:21:19.617554+00:00",
-          "stars": 20,
-          "forks": 10,
-          "watchers": 2,
-          "open_issues": 1,
-          "size": 44098,
-          "views_14d": 226,
+          "repo_id": "VectorInstitute/bias-in-the-picture-benchmark",
+          "name": "bias-in-the-picture-benchmark",
+          "timestamp": "2025-12-23T15:53:01.720803+00:00",
+          "stars": 3,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 9705,
+          "views_14d": 3,
+          "unique_visitors_14d": 3,
+          "clones_14d": 4,
+          "unique_cloners_14d": 4,
+          "language": "Python",
+          "created_at": "2025-11-21T16:57:41Z",
+          "updated_at": "2025-11-26T21:34:25Z",
+          "topics": []
+        }
+      ]
+    },
+    "VectorInstitute/kg-rag": {
+      "name": "kg-rag",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/kg-rag",
+          "name": "kg-rag",
+          "timestamp": "2025-11-25T19:21:19.617554+00:00",
+          "stars": 20,
+          "forks": 10,
+          "watchers": 2,
+          "open_issues": 1,
+          "size": 44098,
+          "views_14d": 226,
           "unique_visitors_14d": 75,
           "clones_14d": 37,
           "unique_cloners_14d": 22,
@@ -4027,6 +4310,28 @@
             "llms",
             "rag"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/kg-rag",
+          "name": "kg-rag",
+          "timestamp": "2025-12-23T15:53:10.317199+00:00",
+          "stars": 22,
+          "forks": 10,
+          "watchers": 2,
+          "open_issues": 1,
+          "size": 44565,
+          "views_14d": 448,
+          "unique_visitors_14d": 69,
+          "clones_14d": 118,
+          "unique_cloners_14d": 59,
+          "language": "Python",
+          "created_at": "2024-12-11T17:22:56Z",
+          "updated_at": "2025-12-22T12:07:19Z",
+          "topics": [
+            "knowledge-graph",
+            "llms",
+            "rag"
+          ]
         }
       ]
     },
@@ -4298,6 +4603,28 @@
             "interpretability",
             "machine-learning"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/interpretability",
+          "name": "interpretability",
+          "timestamp": "2025-12-23T15:53:15.383743+00:00",
+          "stars": 5,
+          "forks": 0,
+          "watchers": 7,
+          "open_issues": 1,
+          "size": 552941,
+          "views_14d": 13,
+          "unique_visitors_14d": 5,
+          "clones_14d": 13,
+          "unique_cloners_14d": 9,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-09-19T15:22:45Z",
+          "updated_at": "2025-12-08T20:21:38Z",
+          "topics": [
+            "ai",
+            "interpretability",
+            "machine-learning"
+          ]
         }
       ]
     },
@@ -4641,6 +4968,32 @@
             "vllm",
             "vlm"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/vector-inference",
+          "name": "vector-inference",
+          "timestamp": "2025-12-23T15:52:49.231622+00:00",
+          "stars": 87,
+          "forks": 12,
+          "watchers": 7,
+          "open_issues": 9,
+          "size": 4915,
+          "views_14d": 395,
+          "unique_visitors_14d": 80,
+          "clones_14d": 208,
+          "unique_cloners_14d": 86,
+          "language": "Python",
+          "created_at": "2024-03-06T01:36:48Z",
+          "updated_at": "2025-12-16T00:45:27Z",
+          "topics": [
+            "inference",
+            "llm",
+            "llm-inference",
+            "reward-modeling",
+            "text-embedding",
+            "vllm",
+            "vlm"
+          ]
         }
       ]
     },
@@ -4919,6 +5272,27 @@
             "diffusion-models",
             "synthetic-data"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/diffusion-models",
+          "name": "diffusion-models",
+          "timestamp": "2025-12-23T15:53:16.421367+00:00",
+          "stars": 5,
+          "forks": 0,
+          "watchers": 10,
+          "open_issues": 1,
+          "size": 272452,
+          "views_14d": 4,
+          "unique_visitors_14d": 4,
+          "clones_14d": 14,
+          "unique_cloners_14d": 8,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-06-12T17:52:14Z",
+          "updated_at": "2025-12-01T17:38:22Z",
+          "topics": [
+            "diffusion-models",
+            "synthetic-data"
+          ]
         }
       ]
     },
@@ -5158,6 +5532,24 @@
           "created_at": "2024-09-12T17:32:48Z",
           "updated_at": "2025-12-19T18:38:11Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/pmc-data-extraction",
+          "name": "pmc-data-extraction",
+          "timestamp": "2025-12-23T15:53:18.349914+00:00",
+          "stars": 14,
+          "forks": 1,
+          "watchers": 1,
+          "open_issues": 6,
+          "size": 13482,
+          "views_14d": 283,
+          "unique_visitors_14d": 17,
+          "clones_14d": 11,
+          "unique_cloners_14d": 10,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-09-12T17:32:48Z",
+          "updated_at": "2025-12-19T18:38:11Z",
+          "topics": []
         }
       ]
     },
@@ -5421,6 +5813,27 @@
             "ai",
             "deployment"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/ai-deployment",
+          "name": "ai-deployment",
+          "timestamp": "2025-12-23T15:53:26.312750+00:00",
+          "stars": 8,
+          "forks": 29,
+          "watchers": 4,
+          "open_issues": 0,
+          "size": 18502,
+          "views_14d": 2,
+          "unique_visitors_14d": 2,
+          "clones_14d": 10,
+          "unique_cloners_14d": 9,
+          "language": "Python",
+          "created_at": "2024-06-03T19:08:04Z",
+          "updated_at": "2025-11-27T02:32:45Z",
+          "topics": [
+            "ai",
+            "deployment"
+          ]
         }
       ]
     },
@@ -5660,6 +6073,24 @@
           "created_at": "2024-10-09T20:05:04Z",
           "updated_at": "2025-09-01T03:13:59Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/bias-mitigation-unlearning",
+          "name": "bias-mitigation-unlearning",
+          "timestamp": "2025-12-23T15:53:11.359562+00:00",
+          "stars": 3,
+          "forks": 2,
+          "watchers": 1,
+          "open_issues": 6,
+          "size": 383,
+          "views_14d": 4,
+          "unique_visitors_14d": 3,
+          "clones_14d": 7,
+          "unique_cloners_14d": 6,
+          "language": "Python",
+          "created_at": "2024-10-09T20:05:04Z",
+          "updated_at": "2025-09-01T03:13:59Z",
+          "topics": []
         }
       ]
     },
@@ -5923,6 +6354,27 @@
             "rag",
             "retrieval-augmented-generation"
           ]
+        },
+        {
+          "repo_id": "vectorinstitute/retrieval-augmented-generation",
+          "name": "retrieval-augmented-generation",
+          "timestamp": "2025-12-23T15:53:09.340353+00:00",
+          "stars": 30,
+          "forks": 21,
+          "watchers": 24,
+          "open_issues": 1,
+          "size": 49324,
+          "views_14d": 61,
+          "unique_visitors_14d": 21,
+          "clones_14d": 54,
+          "unique_cloners_14d": 31,
+          "language": "Jupyter Notebook",
+          "created_at": "2023-11-30T19:17:30Z",
+          "updated_at": "2025-12-15T14:42:58Z",
+          "topics": [
+            "rag",
+            "retrieval-augmented-generation"
+          ]
         }
       ]
     },
@@ -6162,6 +6614,24 @@
           "created_at": "2025-05-22T15:49:19Z",
           "updated_at": "2025-11-25T20:44:42Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/crisp-nam",
+          "name": "crisp-nam",
+          "timestamp": "2025-12-23T15:52:53.321341+00:00",
+          "stars": 2,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 1,
+          "size": 19525,
+          "views_14d": 45,
+          "unique_visitors_14d": 6,
+          "clones_14d": 16,
+          "unique_cloners_14d": 13,
+          "language": "Python",
+          "created_at": "2025-05-22T15:49:19Z",
+          "updated_at": "2025-11-25T20:44:42Z",
+          "topics": []
         }
       ]
     },
@@ -6505,6 +6975,32 @@
             "zero-shot-classification",
             "zero-shot-retrieval"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/mmlearn",
+          "name": "mmlearn",
+          "timestamp": "2025-12-23T15:52:54.256364+00:00",
+          "stars": 19,
+          "forks": 3,
+          "watchers": 4,
+          "open_issues": 7,
+          "size": 5305,
+          "views_14d": 32,
+          "unique_visitors_14d": 13,
+          "clones_14d": 125,
+          "unique_cloners_14d": 57,
+          "language": "Python",
+          "created_at": "2024-08-07T18:50:11Z",
+          "updated_at": "2025-12-16T22:24:53Z",
+          "topics": [
+            "clip",
+            "contrastive-learning",
+            "i-jepa",
+            "multi-task-learning",
+            "multimodal-learning",
+            "zero-shot-classification",
+            "zero-shot-retrieval"
+          ]
         }
       ]
     },
@@ -6768,6 +7264,27 @@
             "alignment",
             "fine-tuning"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/finetuning-and-alignment",
+          "name": "finetuning-and-alignment",
+          "timestamp": "2025-12-23T15:53:20.334294+00:00",
+          "stars": 11,
+          "forks": 3,
+          "watchers": 30,
+          "open_issues": 0,
+          "size": 27777,
+          "views_14d": 1,
+          "unique_visitors_14d": 1,
+          "clones_14d": 11,
+          "unique_cloners_14d": 9,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-05-14T03:18:04Z",
+          "updated_at": "2025-11-27T02:38:26Z",
+          "topics": [
+            "alignment",
+            "fine-tuning"
+          ]
         }
       ]
     },
@@ -7007,6 +7524,24 @@
           "created_at": "2025-10-15T20:14:06Z",
           "updated_at": "2025-12-18T03:17:33Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/masksql",
+          "name": "masksql",
+          "timestamp": "2025-12-23T15:52:57.230262+00:00",
+          "stars": 1,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 3,
+          "size": 6331,
+          "views_14d": 183,
+          "unique_visitors_14d": 5,
+          "clones_14d": 231,
+          "unique_cloners_14d": 71,
+          "language": "Python",
+          "created_at": "2025-10-15T20:14:06Z",
+          "updated_at": "2025-12-18T03:17:33Z",
+          "topics": []
         }
       ]
     },
@@ -7246,6 +7781,24 @@
           "created_at": "2025-01-08T20:10:48Z",
           "updated_at": "2025-12-04T03:29:22Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/fair-sense-ai",
+          "name": "fair-sense-ai",
+          "timestamp": "2025-12-23T15:53:21.457600+00:00",
+          "stars": 6,
+          "forks": 3,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 13906,
+          "views_14d": 51,
+          "unique_visitors_14d": 10,
+          "clones_14d": 26,
+          "unique_cloners_14d": 21,
+          "language": "Python",
+          "created_at": "2025-01-08T20:10:48Z",
+          "updated_at": "2025-12-04T03:29:22Z",
+          "topics": []
         }
       ]
     },
@@ -7576,6 +8129,31 @@
             "healthcare",
             "machine-learning"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/FL4Health",
+          "name": "FL4Health",
+          "timestamp": "2025-12-23T15:53:00.669147+00:00",
+          "stars": 51,
+          "forks": 16,
+          "watchers": 3,
+          "open_issues": 4,
+          "size": 235211,
+          "views_14d": 343,
+          "unique_visitors_14d": 39,
+          "clones_14d": 221,
+          "unique_cloners_14d": 73,
+          "language": "Python",
+          "created_at": "2022-09-16T12:54:29Z",
+          "updated_at": "2025-12-16T20:57:39Z",
+          "topics": [
+            "deep-learning",
+            "distributed-learning",
+            "federated-learning",
+            "federated-learning-framework",
+            "healthcare",
+            "machine-learning"
+          ]
         }
       ]
     },
@@ -7761,6 +8339,24 @@
           "created_at": "2025-06-09T17:34:32Z",
           "updated_at": "2025-11-25T20:14:47Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/linguamark",
+          "name": "linguamark",
+          "timestamp": "2025-12-23T15:53:25.326595+00:00",
+          "stars": 0,
+          "forks": 0,
+          "watchers": 0,
+          "open_issues": 0,
+          "size": 17052,
+          "views_14d": 1,
+          "unique_visitors_14d": 1,
+          "clones_14d": 3,
+          "unique_cloners_14d": 3,
+          "language": "Python",
+          "created_at": "2025-06-09T17:34:32Z",
+          "updated_at": "2025-11-25T20:14:47Z",
+          "topics": []
         }
       ]
     },
@@ -7986,6 +8582,28 @@
             "multimodal-large-language-models",
             "vlm"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/humanibench",
+          "name": "humanibench",
+          "timestamp": "2025-12-23T15:53:13.401822+00:00",
+          "stars": 6,
+          "forks": 1,
+          "watchers": 1,
+          "open_issues": 0,
+          "size": 21607,
+          "views_14d": 45,
+          "unique_visitors_14d": 11,
+          "clones_14d": 11,
+          "unique_cloners_14d": 11,
+          "language": "Python",
+          "created_at": "2025-01-28T14:55:04Z",
+          "updated_at": "2025-11-27T21:43:32Z",
+          "topics": [
+            "evaluation-framework",
+            "multimodal-large-language-models",
+            "vlm"
+          ]
         }
       ]
     },
@@ -8135,6 +8753,24 @@
           "created_at": "2023-10-11T15:26:23Z",
           "updated_at": "2025-12-22T01:59:04Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/vbll",
+          "name": "vbll",
+          "timestamp": "2025-12-23T15:53:07.389330+00:00",
+          "stars": 79,
+          "forks": 8,
+          "watchers": 2,
+          "open_issues": 4,
+          "size": 551,
+          "views_14d": 179,
+          "unique_visitors_14d": 36,
+          "clones_14d": 21,
+          "unique_cloners_14d": 18,
+          "language": "Python",
+          "created_at": "2023-10-11T15:26:23Z",
+          "updated_at": "2025-12-22T01:59:04Z",
+          "topics": []
         }
       ]
     },
@@ -8287,6 +8923,27 @@
             "hvac-control",
             "reinforcement-learning"
           ]
+        },
+        {
+          "repo_id": "VectorInstitute/HV-Ai-C",
+          "name": "HV-Ai-C",
+          "timestamp": "2025-12-23T15:53:22.417700+00:00",
+          "stars": 74,
+          "forks": 22,
+          "watchers": 6,
+          "open_issues": 1,
+          "size": 223,
+          "views_14d": 41,
+          "unique_visitors_14d": 23,
+          "clones_14d": 16,
+          "unique_cloners_14d": 14,
+          "language": "Python",
+          "created_at": "2022-03-03T16:55:04Z",
+          "updated_at": "2025-12-03T19:07:08Z",
+          "topics": [
+            "hvac-control",
+            "reinforcement-learning"
+          ]
         }
       ]
     },
@@ -8400,9 +9057,175 @@
           "created_at": "2025-03-18T18:06:25Z",
           "updated_at": "2025-11-26T21:32:12Z",
           "topics": []
+        },
+        {
+          "repo_id": "VectorInstitute/mcp-goodnews",
+          "name": "mcp-goodnews",
+          "timestamp": "2025-12-23T15:53:24.335167+00:00",
+          "stars": 44,
+          "forks": 9,
+          "watchers": 0,
+          "open_issues": 1,
+          "size": 101,
+          "views_14d": 45,
+          "unique_visitors_14d": 14,
+          "clones_14d": 44,
+          "unique_cloners_14d": 33,
+          "language": "Python",
+          "created_at": "2025-03-18T18:06:25Z",
+          "updated_at": "2025-11-26T21:32:12Z",
+          "topics": []
+        }
+      ]
+    },
+    "VectorInstitute/aieng-template-webpage": {
+      "name": "aieng-template-webpage",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/aieng-template-webpage",
+          "name": "aieng-template-webpage",
+          "timestamp": "2025-12-23T15:52:50.314764+00:00",
+          "stars": 1,
+          "forks": 0,
+          "watchers": 1,
+          "open_issues": 0,
+          "size": 528,
+          "views_14d": 19,
+          "unique_visitors_14d": 2,
+          "clones_14d": 155,
+          "unique_cloners_14d": 54,
+          "language": "TypeScript",
+          "created_at": "2025-01-17T16:11:31Z",
+          "updated_at": "2025-12-22T07:02:08Z",
+          "topics": []
+        }
+      ]
+    },
+    "VectorInstitute/aieng-template-uv": {
+      "name": "aieng-template-uv",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/aieng-template-uv",
+          "name": "aieng-template-uv",
+          "timestamp": "2025-12-23T15:52:52.307266+00:00",
+          "stars": 7,
+          "forks": 1,
+          "watchers": 3,
+          "open_issues": 0,
+          "size": 2107,
+          "views_14d": 169,
+          "unique_visitors_14d": 11,
+          "clones_14d": 414,
+          "unique_cloners_14d": 131,
+          "language": "Python",
+          "created_at": "2025-01-20T16:19:12Z",
+          "updated_at": "2025-12-23T00:19:19Z",
+          "topics": [
+            "python3",
+            "template"
+          ]
+        }
+      ]
+    },
+    "VectorInstitute/aieng-template-implementation": {
+      "name": "aieng-template-implementation",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/aieng-template-implementation",
+          "name": "aieng-template-implementation",
+          "timestamp": "2025-12-23T15:52:56.244743+00:00",
+          "stars": 1,
+          "forks": 0,
+          "watchers": 7,
+          "open_issues": 0,
+          "size": 5554,
+          "views_14d": 137,
+          "unique_visitors_14d": 5,
+          "clones_14d": 242,
+          "unique_cloners_14d": 89,
+          "language": "Jupyter Notebook",
+          "created_at": "2024-04-24T22:30:50Z",
+          "updated_at": "2025-12-23T03:41:28Z",
+          "topics": [
+            "ai",
+            "implementation",
+            "template"
+          ]
+        }
+      ]
+    },
+    "VectorInstitute/aieng-template-mvp": {
+      "name": "aieng-template-mvp",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/aieng-template-mvp",
+          "name": "aieng-template-mvp",
+          "timestamp": "2025-12-23T15:53:02.646476+00:00",
+          "stars": 2,
+          "forks": 1,
+          "watchers": 1,
+          "open_issues": 1,
+          "size": 2604,
+          "views_14d": 99,
+          "unique_visitors_14d": 4,
+          "clones_14d": 631,
+          "unique_cloners_14d": 126,
+          "language": "Python",
+          "created_at": "2025-04-09T15:30:01Z",
+          "updated_at": "2025-12-22T06:49:52Z",
+          "topics": [
+            "mvp",
+            "template"
+          ]
+        }
+      ]
+    },
+    "VectorInstitute/aieng-template-poetry": {
+      "name": "aieng-template-poetry",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/aieng-template-poetry",
+          "name": "aieng-template-poetry",
+          "timestamp": "2025-12-23T15:53:06.417960+00:00",
+          "stars": 4,
+          "forks": 0,
+          "watchers": 7,
+          "open_issues": 6,
+          "size": 831,
+          "views_14d": 17,
+          "unique_visitors_14d": 5,
+          "clones_14d": 12,
+          "unique_cloners_14d": 8,
+          "language": "Python",
+          "created_at": "2022-03-14T14:55:29Z",
+          "updated_at": "2025-05-15T22:16:23Z",
+          "topics": []
+        }
+      ]
+    },
+    "VectorInstitute/aieng-template-blog": {
+      "name": "aieng-template-blog",
+      "snapshots": [
+        {
+          "repo_id": "VectorInstitute/aieng-template-blog",
+          "name": "aieng-template-blog",
+          "timestamp": "2025-12-23T15:53:08.440350+00:00",
+          "stars": 3,
+          "forks": 0,
+          "watchers": 1,
+          "open_issues": 0,
+          "size": 1052,
+          "views_14d": 133,
+          "unique_visitors_14d": 6,
+          "clones_14d": 398,
+          "unique_cloners_14d": 127,
+          "language": "JavaScript",
+          "created_at": "2025-01-23T16:19:25Z",
+          "updated_at": "2025-12-23T00:19:14Z",
+          "topics": []
         }
       ]
     }
   },
-  "last_updated": "2025-12-22T12:03:09.535058+00:00"
-}
\ No newline at end of file
+  "last_updated": "2025-12-23T15:53:26.312750+00:00"
+}
diff --git a/pyproject.toml b/pyproject.toml
index 6299433..b4253a9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -8,7 +8,9 @@ license = "Apache-2.0"
 repository = "https://github.com/VectorInstitute/implementation-catalog"
 requires-python = ">=3.12"
 dependencies = [
+    "filelock==3.20.1",
     "pyyaml>=6.0.2",
+    "urllib3==2.6.0",
 ]
 
 [dependency-groups]
diff --git a/scripts/collect_github_metrics.py b/scripts/collect_github_metrics.py
index 9d462df..1116e00 100755
--- a/scripts/collect_github_metrics.py
+++ b/scripts/collect_github_metrics.py
@@ -65,6 +65,56 @@ def check_gh_installed() -> bool:
         return False
 
 
+def get_template_repos() -> List[str]:
+    """Discover template repositories in VectorInstitute org via GitHub API.
+
+    Returns
+    -------
+    List[str]
+        List of template repository IDs matching aieng-template-* pattern.
+
+    """
+    print("Discovering template repositories...")
+
+    try:
+        # Query GitHub API for all VectorInstitute repos
+        result = subprocess.run(
+            [
+                "gh",
+                "api",
+                "orgs/VectorInstitute/repos",
+                "--paginate",
+                "--jq",
+                '.[] | select(.name | startswith("aieng-template-")) | .full_name',
+            ],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        if not result.stdout:
+            print("Warning: No template repos found", file=sys.stderr)
+            return []
+
+        # Parse the result - one repo per line
+        template_repos = [
+            repo.strip() for repo in result.stdout.strip().split("\n") if repo.strip()
+        ]
+
+        print(f"Found {len(template_repos)} template repositories")
+        return template_repos
+
+    except subprocess.CalledProcessError as e:
+        print(
+            f"Warning: Could not fetch template repos from GitHub API: {e.stderr}",
+            file=sys.stderr,
+        )
+        return []
+    except Exception as e:
+        print(f"Warning: Error discovering template repos: {e}", file=sys.stderr)
+        return []
+
+
 def get_repo_ids_from_yaml() -> List[str]:
     """Extract repo_id values from YAML files in repositories/ directory.
 
@@ -287,7 +337,17 @@ def setup_environment() -> tuple[list[str], Path, dict[str, Any]]:
         print("ERROR: No repository IDs found in YAML files.")
         sys.exit(1)
 
-    print(f"Found {len(repo_ids)} repositories to track\n")
+    print(f"Found {len(repo_ids)} catalog repositories")
+
+    # Also get template repositories
+    template_repos = get_template_repos()
+
+    # Combine both lists, avoiding duplicates
+    all_repo_ids = list(set(repo_ids + template_repos))
+
+    print(f"Total repositories to track: {len(all_repo_ids)}")
+    print(f"  - Catalog repos: {len(repo_ids)}")
+    print(f"  - Template repos: {len(template_repos)}\n")
 
     output_dir = Path("catalog/public/data")
     output_dir.mkdir(parents=True, exist_ok=True)
@@ -298,7 +358,7 @@ def setup_environment() -> tuple[list[str], Path, dict[str, Any]]:
         f"Loaded historical data (tracking {len(historical_data.get('repos', {}))} repos)\n"
     )
 
-    return repo_ids, output_dir, historical_data
+    return all_repo_ids, output_dir, historical_data
 
 
 def collect_all_metrics(
diff --git a/uv.lock b/uv.lock
index 8a1e714..eb939c3 100644
--- a/uv.lock
+++ b/uv.lock
@@ -124,11 +124,11 @@ wheels = [
 
 [[package]]
 name = "filelock"
-version = "3.18.0"
+version = "3.20.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0a/10/c23352565a6544bdc5353e0b15fc1c563352101f30e24bf500207a54df9a/filelock-3.18.0.tar.gz", hash = "sha256:adbc88eabb99d2fec8c9c1b229b171f18afa655400173ddc653d5d01501fb9f2", size = 18075 }
+sdist = { url = "https://files.pythonhosted.org/packages/a7/23/ce7a1126827cedeb958fc043d61745754464eb56c5937c35bbf2b8e26f34/filelock-3.20.1.tar.gz", hash = "sha256:b8360948b351b80f420878d8516519a2204b07aefcdcfd24912a5d33127f188c", size = 19476 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4d/36/2a115987e2d8c300a974597416d9de88f2444426de9571f4b59b2cca3acc/filelock-3.18.0-py3-none-any.whl", hash = "sha256:c401f4f8377c4464e6db25fff06205fd89bdd83b65eb0488ed1b160f780e21de", size = 16215 },
+    { url = "https://files.pythonhosted.org/packages/e3/7f/a1a97644e39e7316d850784c642093c99df1290a460df4ede27659056834/filelock-3.20.1-py3-none-any.whl", hash = "sha256:15d9e9a67306188a44baa72f569d2bfd803076269365fdea0934385da4dc361a", size = 16666 },
 ]
 
 [[package]]
@@ -154,7 +154,9 @@ name = "implementation-catalog"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
+    { name = "filelock" },
     { name = "pyyaml" },
+    { name = "urllib3" },
 ]
 
 [package.dev-dependencies]
@@ -165,7 +167,11 @@ dev = [
 ]
 
 [package.metadata]
-requires-dist = [{ name = "pyyaml", specifier = ">=6.0.2" }]
+requires-dist = [
+    { name = "filelock", specifier = "==3.20.1" },
+    { name = "pyyaml", specifier = ">=6.0.2" },
+    { name = "urllib3", specifier = "==2.6.0" },
+]
 
 [package.metadata.requires-dev]
 dev = [
@@ -470,11 +476,11 @@ wheels = [
 
 [[package]]
 name = "urllib3"
-version = "2.5.0"
+version = "2.6.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185 }
+sdist = { url = "https://files.pythonhosted.org/packages/1c/43/554c2569b62f49350597348fc3ac70f786e3c32e7f19d266e19817812dd3/urllib3-2.6.0.tar.gz", hash = "sha256:cb9bcef5a4b345d5da5d145dc3e30834f58e8018828cbc724d30b4cb7d4d49f1", size = 432585 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795 },
+    { url = "https://files.pythonhosted.org/packages/56/1a/9ffe814d317c5224166b23e7c47f606d6e473712a2fad0f704ea9b99f246/urllib3-2.6.0-py3-none-any.whl", hash = "sha256:c90f7a39f716c572c4e3e58509581ebd83f9b59cced005b7db7ad2d22b0db99f", size = 131083 },
 ]
 
 [[package]]